Спостерігач (шаблон проєктування)

using System;
using System.Collections;
using System.Threading;

namespace Observer {
    /// <summary>
    /// Observer Pattern Judith Bishop Jan 2007
    /// 
    /// The Subject runs in a thread and changes its state
    /// independently. At each change, it notifies its Observers.
    /// </summary>
    class Program {
        static void Main(string[] args) {
            Subject subject = new Subject();
            Observer Observer = new Observer(subject,"Center","\t\t");
            Observer observer2 = new Observer(subject,"Right","\t\t\t\t");
            subject.Go();

            // Wait for user
            Console.Read();
        }
    }

    class Simulator : IEnumerable {
        string [] moves = {"5","3","1","6","7"};
        public IEnumerator GetEnumerator() {
            foreach( string element in moves )
                yield return element;
        }
    }

    class Subject {
        public delegate void Callback (string s);
        public event Callback Notify;
        Simulator simulator = new Simulator( );
        const int speed = 200;
        public string SubjectState { get; set; }
        public void Go() {
            new Thread(new ThreadStart(Run)).Start( );
        }
        void Run () {
            foreach (string s in simulator) {
                Console.WriteLine("Subject: " + s);
                SubjectState = s;
                Notify(s);
                Thread.Sleep(speed); // milliseconds
            }
        }
    }
    interface IObserver {
        void Update(string state);
    }

    class Observer : IObserver {
        string name;
        Subject subject;
        string state;
        string gap;
        public Observer(Subject subject, string name, string gap) {
            this.subject = subject;
            this.name = name;
            this.gap = gap;
            subject.Notify += Update;
        }
        public void Update(string subjectState) {
            state = subjectState;
            Console.WriteLine(gap + name + ": " + state);
        }
    }
}

namespace ObserverPattern.Interfaces
{
	interface IEvent
	{

	}

	interface IObserver<in TEvent> where TEvent : IEvent
	{
		void Handle(object sender, TEvent eventArgs);
	}

	interface ISubject<TEvent> where TEvent : IEvent
	{
		void Notify(TEvent raisedEvent);
		void Add(IObserver<TEvent> observer);
		void Remove(IObserver<TEvent> observer);
	}

	class UserRenamedEvent : IEvent 
	{
		public string Name { get; }

		public UserRenamedEvent(string name)
		{
			Name = name;
		}
	}

	class User : ISubject<UserRenamedEvent>
	{
		private string _name;
		public string Name 
		{
			get
			{
				return _name;
			}
			set
			{
				_name = value;

				this.Notify(new UserRenamedEvent(value));
			} 
		}

		private readonly ICollection<IObserver<UserRenamedEvent>> _userRenamedObservers = new List<IObserver<UserRenamedEvent>>();

		public void Add(IObserver<UserRenamedEvent> observer)
		{
			_userRenamedObservers.Add(observer);
		}

		public void Remove(IObserver<UserRenamedEvent> observer)
		{
			_userRenamedObservers.Remove(observer);
		}

		public void Notify(UserRenamedEvent raisedEvent)
		{
			foreach (var observer in _userRenamedObservers)
			{
				observer.Handle(this, raisedEvent);
			}
		}
	}

	class ConsoleLogger : IObserver<UserRenamedEvent>
	{
		public void Handle(object sender, UserRenamedEvent eventArgs)
		{
			Console.WriteLine($"User has been renamed to [{eventArgs.Name}]");
		}
	}

	class Program
	{
		static void Main(string[] args)
		{
			var logger = new ConsoleLogger();

			var user = new User();
			user.Add(logger);
			user.Name = "John Doe";
		}
	}
}

namespace ObserverPattern.Events
{
	class UserRenamedEvent : EventArgs 
	{
		public string Name { get; }

		public UserRenamedEvent(string name)
		{
			Name = name;
		}
	}

	class User 
	{
		private string _name;
		public string Name 
		{
			get
			{
				return _name;
			}
			set
			{
				_name = value;

				this.OnUserRenamed(new UserRenamedEvent(value));
			} 
		}

		public event EventHandler<UserRenamedEvent> UserRenamedEvent;

		// keep this protected to override event in derived class
		protected void OnUserRenamed(UserRenamedEvent raisedEvent)
		{
			UserRenamedEvent?.Invoke(this, raisedEvent);
		}
	}

	class ConsoleLogger
	{
		public void Handle(object sender, UserRenamedEvent eventArgs)
		{
			Console.WriteLine($"User has been renamed to [{eventArgs.Name}]");
		}
	}

	class Program
	{
		static void Main(string[] args)
		{
			var logger = new ConsoleLogger();

			var user = new User();
			user.UserRenamedEvent += logger.Handle;
			user.Name = "John Doe";
		}
	}
}

namespace ObserverPattern.EventService
{
	interface IEvent
	{

	}

	interface IEventHandler<in TEvent> where TEvent : IEvent
	{
		void Handle(object sender, TEvent raisedEvent);
	}

	interface IEventService 
	{
		void Publish<TEvent>(object sender, TEvent raisedEvent)
			where TEvent : IEvent;

		void Subscribe<TEvent, THandler>()
			where TEvent : IEvent
			where THandler : IEventHandler<TEvent>;
	}

	class EventService : IEventService
	{
		private readonly IDictionary<Type, List<Type>> _eventHandlers = new Dictionary<Type, List<Type>>();

		public void Publish<TEvent>(object sender, TEvent raisedEvent) where TEvent : IEvent
		{
			var eventType = typeof(TEvent);

			if (!_eventHandlers.ContainsKey(eventType)) return;

			foreach (var handlerType in _eventHandlers[eventType])
			{
				var handler = Activator.CreateInstance(handlerType) as IEventHandler<TEvent>;

				handler.Handle(sender, raisedEvent);
			}
		}

		public void Subscribe<TEvent, THandler>()
			where TEvent : IEvent
			where THandler : IEventHandler<TEvent>
		{
			var eventType = typeof(TEvent);
			var handlerType = typeof(THandler);

			if (!_eventHandlers.ContainsKey(eventType))
			{
				_eventHandlers.Add(eventType, new List<Type>());
			}

			if (_eventHandlers[eventType].Any(ht => ht == handlerType))
			{
				throw new ArgumentException($"Handler Type {handlerType.Name} already is registered for '{eventType.Name}'");
			}

			_eventHandlers[eventType].Add(handlerType);
		}

		public static EventService Instance { get; }
		private EventService() { }
		static EventService()
		{
			Instance = new EventService();
		}
	}

	class UserRenamedEvent : IEvent 
	{
		public string Name { get; }

		public UserRenamedEvent(string name)
		{
			Name = name;
		}
	}

	class User 
	{
		private string _name;
		public string Name 
		{
			get
			{
				return _name;
			}
			set
			{
				_name = value;

				EventService.Instance.Publish(this, new UserRenamedEvent(value));
			} 
		}
	}

	class ConsoleLogger : IEventHandler<UserRenamedEvent>
	{
		public void Handle(object sender, UserRenamedEvent eventArgs)
		{
			Console.WriteLine($"User has been renamed to [{eventArgs.Name}]");
		}
	}

	class Program
	{
		static void Main(string[] args)
		{
			EventService.Instance.Subscribe<UserRenamedEvent, ConsoleLogger>();

			var user = new User();
			user.Name = "John Doe";
		}
	}
}