Observer Pattern With C# 4.0

Observer Pattern

"The Observer Pattern Defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically."

Publishers + Subscribers = Observer Pattern

C# Introduced , IObserver<T> and IObservable<T> which will help push-based notification,also known as the observer design pattern. The IObservable<T> interface represents the class that sends notifications (the provider); the IObserver<T> interface represents the class that receives them (the observer). T represents the class that provides the notification information.

An IObserver<T> implementation arranges to receive notifications from a provider (an IObservable<T> implementation) by passing an instance of itself to the provider's IObservable<T>.Subscribe method. This method returns an IDisposable object that can be used to unsubscribe the observer before the provider finishes sending notifications.

The IObserver<T> interface defines the following three methods that the observer must implement:

The OnNext method, which is typically called by the provider to supply the observer with new data or state information.

The OnError method, which is typically called by the provider to indicate that data is unavailable, inaccessible, or corrupted, or that the provider has experienced some other error condition.

The OnCompleted method, which is typically called by the provider to indicate that it has finished sending notifications to observers.

WeatherData.cs

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace ObserverPatternInCsharp  
 {  
   public class WeatherData  
   {  
     private float temperature;  
     private float humidity;  
     private float presssure;  
     public WeatherData(float temp,float hum, float press)  
     {  
       temperature = temp;  
       humidity = hum;  
       presssure = press;  
     }  
     public float Temperature  
     {  
       get { return this.temperature; }  
     }  
     public float Humidity  
     {  
       get { return this.humidity; }  
     }  
     public float Presssure  
     {  
       get { return this.presssure; }  
     }  
   }  
 }  

WeatherProvider.cs

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace ObserverPatternInCsharp  
 {  
   public class WeatherProvider: IObserver<WeatherData>  
   {  
     private IDisposable unsubscriber;  
     private string instName;  
     public WeatherProvider(string name)  
     {  
       this.instName = name;  
     }  
     public string Name  
     {  
       get { return this.instName; }  
     }  
     public virtual void Subscribe(IObservable<WeatherData> provider)  
     {  
       if (provider != null)  
         unsubscriber = provider.Subscribe(this);  
     }  
     void IObserver<WeatherData>.OnCompleted()  
     {  
       Console.WriteLine("The Provider has completed transmitting data to {0}.", this.Name);  
       this.Unsubscribe();  
     }  
     public virtual void Unsubscribe()  
     {  
       unsubscriber.Dispose();  
     }  
     void IObserver<WeatherData>.OnError(Exception error)  
     {  
       Console.WriteLine("{0}: The provider cannot be read data.", this.Name);  
     }  
     void IObserver<WeatherData>.OnNext(WeatherData value)  
     {  
       Console.WriteLine("{3}: The current Weather is Temperature: {0}, Pressure {1}, Humidty {2}", value.Temperature, value.Presssure, value.Humidity,this.Name);  
     }  
   }  
 }  

WeatherSubscriber.cs

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace ObserverPatternInCsharp  
 {  
   public class WeatherSubscriber : IObservable<WeatherData>  
   {  
     private List<IObserver<WeatherData>> observers;  
     public WeatherSubscriber()  
     {  
       observers = new List<IObserver<WeatherData>>();  
     }  
     public IDisposable Subscribe(IObserver<WeatherData> observer)  
     {  
       if (!observers.Contains(observer))  
         observers.Add(observer);  
       return new Unsubscriber(observers, observer);  
     }  
     private class Unsubscriber : IDisposable  
     {  
       private List<IObserver<WeatherData>> _observers;  
       private IObserver<WeatherData> _observer;  
       public Unsubscriber(List<IObserver<WeatherData>> observers, IObserver<WeatherData> observer)  
       {  
         this._observers = observers;  
         this._observer = observer;  
       }  
       public void Dispose()  
       {  
         if (_observer != null && _observers.Contains(_observer))  
           _observers.Remove(_observer);  
       }  
     }  
     public void SetMeasurements(WeatherData weather)  
     {  
       foreach (var observer in observers)  
       {  
         if (weather == null)  
           observer.OnError(new WeatherUnKnnowException());  
         else  
           observer.OnNext(weather);  
       }  
     }  
   }  
 }  

WeatherUnKnnowException.cs

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace ObserverPatternInCsharp  
 {  
   public class WeatherUnKnnowException: Exception  
   {  
     internal WeatherUnKnnowException()  
     { }  
   }  
 }  

Program.cs

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace ObserverPatternInCsharp  
 {  
   public class Program  
   {  
     public static void Main()  
     {  
       WeatherSubscriber subscriber = new WeatherSubscriber();  
       WeatherProvider NDTVProvider = new WeatherProvider("NDTV");  
       NDTVProvider.Subscribe(subscriber);  
       WeatherProvider TimesProvider = new WeatherProvider("Times");  
       TimesProvider.Subscribe(subscriber);  
       WeatherProvider HeadLineProvider = new WeatherProvider("HeadLine");  
       HeadLineProvider.Subscribe(subscriber);  
       subscriber.SetMeasurements(new WeatherData(10, 7, 14));  
       HeadLineProvider.Unsubscribe();  
       subscriber.SetMeasurements(new WeatherData(28,26, 14));  
       subscriber.SetMeasurements(null);  
       Console.Read();  
     }  
   }  
 }