Il pattern Observer è uno dei pattern creazionali più diffusi. Un observer è un oggetto che controlla se qualosa succede... questo qualcosa puo essere implementato con delle funzioni o metodi, o più velocemente con degli eventi. L'uso è molteplice specialmente in risposta a input utente.

L'Observer è costituito da una interfaccia che corrisponde all'oggetto da controllare (detto Subject) e una interfaccia observer vera e propria:

interface ISubject {
   void AttachObserver(IObserver o);
   void DetachObserver(IObserver o);
   void NotifyMessage(string message);
}
interface IObserver {
   void Update(string message)
}
class Subject : ISubject {
   private List<IObserver> Observers = new List<IObserver>();
   void AttachObserver(IObserver o) { Observers.Add(o);  }
   void DetachObserver(IObserver o) { Observers.Remove(o); }
   void NotifyMessage(string message)
   {
       foreach (IObserver o in Observers) { o.Update(message);  } // notifico il messaggio a tutti gli observer collegati
    } 
}
class Observer : IObserver {
   void Update(string message) {  System.Diagnostics.Trace.WriteLine(message); }
}

In una implementazione ad eventi:

interface ISubject {
   delegate void NotifyEventHandler(string message);
   void AttachObserver(IObserver o);
   void DetachObserver(IObserver o);
   event NotifyEventHandler NotifyMessage;
}
interface IObserver {
   void Update(string message)
}
class Subject : ISubject {
   //sparisce la lista perchè il gestore degli eventi è in grado di funzionare con più handler
   void AttachObserver(IObserver o) { Notify += o.Update; } // if Notify!=null non si fa perchè deve poter gestire più observer
   void DetachObserver(IObserver o) { Notify -= o.Update; } 
   public event Notify;
}
class Observer : IObserver {
   void Update(string message) {  System.Diagnostics.Trace.WriteLine(message); }
}

come si puo notare, l'implementazione ad eventi in .NET è molto pulita e rapida da realizzare..