Mediator_Group_Classes.cs

Go to the documentation of this file.

 
 
// The Mediator pattern acts as a go-between for multiple entities that want
// no knowledge of any of the other entities except at the most abstract
// level.
//
// The classes defined in this module are for handling groups.  These classes
// have no knowledge of the User class or the mediator class itself.
//
// This is a dead simple implementation of the concept of a group.  There is
// only a name of the group and the list of users (identified by name) being
// tracked here.
using System;
using System.Collections.Generic;
 
namespace DesignPatternExamples_csharp
{
    public class Group
    {
        private List<string> _users = new List<string>();
 
        internal Group(string name)
        {
            Name = name;
        }
 
        public string Name { get; }
 
        public string[] Users
        {
            get
            {
                return _users.ToArray();
            }
        }
 
        public bool ContainsUser(string name)
        {
            return _users.Contains(name);
        }
 
        public void AddUser(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name", "Must specify a user name to add it to the group.");
            }
 
            if (!ContainsUser(name))
            {
                _users.Add(name);
            }
        }
 
 
        public void RemoveUser(string name)
        {
            if (_users.Contains(name))
            {
                _users.Remove(name);
            }
        }
 
        public override bool Equals(object? obj)
        {
            if (obj != null)
            {
                if (obj is Group)
                {
                    return ((Group)obj).Name == Name;
                }
                if (obj is string)
                {
                    return (string)obj == Name;
                }
            }
            return false;
        }
 
        public override int GetHashCode()
        {
            return Name.GetHashCode();
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public class GroupList
    {
        private List<Group> _groups = new List<Group>();
 
 
        public string[] GroupNames
        {
            get
            {
                List<string> groupNames = new List<string>();
                foreach (Group group in _groups)
                {
                    groupNames.Add(group.Name);
                }
                groupNames.Sort();
                return groupNames.ToArray();
            }
        }
 
 
        public Group? FindGroup(string name)
        {
            return _groups.Find(x => x.Equals(name));
        }
 
 
        public void AddGroup(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name", "Must specify a group name to add it to the group list.");
            }
 
            Group newGroup = new Group(name);
            if (!_groups.Contains(newGroup))
            {
                _groups.Add(newGroup);
            }
        }
 
 
        public void RemoveGroup(string name)
        {
            Group existingGroup = new Group(name);
            if (_groups.Contains(existingGroup))
            {
                _groups.Remove(existingGroup);
            }
        }
    }
}