Observer Design Pattern

A.Observer.Design.Pattern.cs

namespace Observer
{
    class Program
    {
        /*
         * The Observer pattern allows you to define a one-to-many dependency between objects so that when one object changes state, all its 
         * dependents are notified and updated automatically. Note that the `event` keyword is a dot net implementation of the observer pattern.
         */
        static void Main(string[] args)
        {
            var chatRoom = new ChatRoom();
            chatRoom.AttachObserver(new User1());
            chatRoom.AttachObserver(new User2());
            chatRoom.BroadcastMessage("Hello from the server!");

            Console.ReadLine();
        }
    }
}

B.ChatRoom.cs

namespace Observer
{
    public class ChatRoom
    {
        private readonly ICollection<IObserver> _observers;

        public ChatRoom() 
        {
            _observers = new List<IObserver>();
        }

        public void AttachObserver(IObserver observer) => _observers.Add(observer);

        public void BroadcastMessage(string message) 
        {
            foreach(var observer in _observers)
            {
                observer.Notify(message);
            }
        }
    }
}

C.IObserver.cs

namespace Observer
{
    public interface IObserver
    {
        void Notify<T>(T message);
    }
}

C.User2.cs

namespace Observer
{
    public class User2 : IObserver
    {
        public User2()
        {
        }

        public void Notify<T>(T message)
        {
            Console.WriteLine($"{message} was received by user2");
        }
    }
}

D.User1.cs

namespace Observer
{
    public class User1 : IObserver
    {
        public User1()
        {
        }

        public void Notify<T>(T message)
        {
            Console.WriteLine($"{message} was received by user1");
        }
    }
}