C# Observer Design Pattern with The IObserver<T> and IObservable<T> interfaces

IObserver<T> interface와 IObservable<T> interface를 이용해 Observer Design Pattern을 구현해 보자.

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Observer
{
    class Program
    {
        static void Main(string[] args)
        {
            LocationTracker provider = new LocationTracker();
            // Provider 생성
 
            LocationReporter reporter1 = new LocationReporter("FixedGPS");
            reporter1.Subscribe(provider);
            // Observer(FixedGPS) 생성 및 Provider에 등록
 
            LocationReporter reporter2 = new LocationReporter("MobileGPS");
            reporter2.Subscribe(provider);
            // Observer(MobileGPS) 생성 및 Provider에 등록
 
            provider.TrackLocation(new Location(47.6456, -122.1312));
            // FixedGPS: The current location is 47.6456, -122.1312
            // MobileGPS: The current location is 47.6456, -122.1312
 
            reporter1.Unsubscribe();
            // FixedGPS unsubscribed.
 
            provider.TrackLocation(new Location(47.6677, -122.1199));
            // MobileGPS: The current location is 47.6677, -122.1199
 
            provider.TrackLocation(null);
            // MobileGPS: The location cannot be determined.
 
            provider.EndTransmission();
            // MobileGPS unsubscribed.
            // The Location Tracker has completed transmitting data to MobileGPS.
        }
    }
 
    // 위치 정보를 담고 있는 데이터 클래스
    public struct Location
    {
        double lat, lon;
 
        public Location(double latitude, double longitude)
        {
            lat = latitude;
            lon = longitude;
        }
 
        public double Latitude
        {
            get { return lat; }
        }
 
        public double Longitude
        {
            get { return lon; }
        }
    }
 
    // Provider 클래스 (등록된(subscribe) Observer에 Notification을 보낸다)
    // IObservable<out T> 인터페이스는 IDisposable Subscribe(IObserver<T> observer)를 구현해야 한다.
    public class LocationTracker : IObservable<Location>
    {
        private List<IObserver<Location>> observers;
 
        public LocationTracker()
        {
            observers = new List<IObserver<Location>>();
        }
 
        // Subscribe()는 LocationTracker 클래스에서 호출되지 않는다. LocationReporter.Subscribe()에서 호출
        public IDisposable Subscribe(IObserver<Location> observer)
        {
            if (!observers.Contains(observer))
                observers.Add(observer);
 
            return new Unsubscriber(observers, observer);
        }
 
        private class Unsubscriber : IDisposable
        {
            private List<IObserver<Location>> _observers;
            private IObserver<Location> _observer;
 
            public Unsubscriber(List<IObserver<Location>> observers, IObserver<Location> observer)
            {
                _observers = observers;
                _observer = observer;
            }
 
            public void Dispose()
            {
                if (_observer != null && _observers.Contains(_observer))
                    _observers.Remove(_observer);
            }
        }
 
        public void TrackLocation(Nullable<Location> loc)
        {
            // observers 순회하는 예 1
            foreach (IObserver<Location> observer in observers)
            {
                if (!loc.HasValue)
                    observer.OnError(new LocationUnknownException());
                else
                    observer.OnNext(loc.Value);
            }
        }
 
        public void EndTransmission()
        {
            // observers 순회하는 예 2
            foreach (IObserver<Location> observer in observers.ToArray())
                if (observers.Contains(observer))
                    observer.OnCompleted();
 
            observers.Clear();
        }
    }
 
    // LocationTracker.TrackLocation()에 Location 정보가 없을때 보내는 예외 클래스
    public class LocationUnknownException : Exception
    {
        internal LocationUnknownException() : base("The location cannot be determined.")
        { }
    }
 
    // Observer 클래스 (Provider에 등록(subscribe)하고 Notification을 받는다)
    // IObserver<in T> 인터페이스는 아래 3개의 매소드를 구현해야 한다.
    // void OnCompleted(), void OnError(Exception error), void OnNext(T value);
    public class LocationReporter : IObserver<Location>
    {
        private IDisposable unsubscriber;
        private string instName;
 
        public LocationReporter(string name)
        {
            instName = name;
        }
 
        public string Name
        { get { return instName; } }
 
        public virtual void Subscribe(IObservable<Location> provider)
        {
            if (provider != null)
                unsubscriber = provider.Subscribe(this);
        }
 
        public virtual void OnCompleted()
        {
            Unsubscribe();
            Console.WriteLine("The Location Tracker has completed transmitting data to {0}.", Name);
        }
 
        public virtual void OnError(Exception e)
        {
            Console.WriteLine("{0}: {1}", Name, e.Message);
        }
 
        public virtual void OnNext(Location value)
        {
            Console.WriteLine("{2}: The current location is {0}, {1}", value.Latitude, value.Longitude, Name);
        }
 
        public virtual void Unsubscribe()
        {
            unsubscriber.Dispose();
            Console.WriteLine("{0} unsubscribed.", Name);
        }
    }
}

 

소스를 입력하고 빌드한다.

 

위치정보 Notification이 잘 전달된다.

 

※참고

The IObserver<T> and IObservable<T> interfaces provide a generalized mechanism for push-based notification, also known as the observer design pattern.