Behavioral Patterns – Observer

Observer – It lets the programs define a subscription mechanism to notify multiple objects, which means when the events happen, other objects can observe and immediately respond or modify object property.

From Design Pattern – Behavioral Patterns

Structure

Applicability

• Using its pattern when the programs change to the object state may require changing other objects, and the actual object sets are unknown beforehand or change dynamically.
• Using its pattern when some objects must observe others in the program, but it is only for a limited time or in specific situations.

Pros and Cons

How to Implement

#1 Basic Sample

static void Main(string[] args)
{
 var subject = new Subject();
 var ObserverA = new ConcreteObserver();
 subject.Attach(ObserverA);

 var ObserverB = new AnotherConcreteObserver();
 subject.Attach(ObserverB);

 subject.BusinessLogic();
 subject.BusinessLogic();
 
 subject.Detach(ObserverB);

 subject.BusinessLogic();

 Console.ReadKey();
}

public interface IObserver
{
 void Update(ISubject subject);
}

public interface ISubject
{
 void Attach(IObserver observer);
 void Detach(IObserver observer);
 void Notify();
}

public class Subject : ISubject
{
 public int State { get; set; } = -0;

 private List<IObserver> _observersList = new List<IObserver>();

 public void Attach(IObserver observer)
 {
  Console.WriteLine("Subject: Attached an object.");
  _observersList.Add(observer);
 }

 public void Detach(IObserver observer)
 {
  _observersList.Remove(observer);
  Console.WriteLine("Subject: Detached objects.");
 }

 public void Notify()
 {
  Console.WriteLine("Subject: Notifying observers.");

  foreach (var observer in _observersList)
   observer.Update(this);
 }

 public void BusinessLogic()
 {
  Console.WriteLine("\nSubject: Do something important.");
  State = new Random().Next(0, 10);

  Thread.Sleep(15);

  Console.WriteLine("Subject: My state has just changed to: " + State);
  Notify();
 }
}

public class ConcreteObserver : IObserver
{
 public void Update(ISubject subject)
 {
  if ((subject as Subject).State < 3)
   Console.WriteLine("Concrete Observer: Reacted to the event.");
 }
}

public class AnotherConcreteObserver : IObserver
{
 public void Update(ISubject subject)
 {
  if ((subject as Subject).State == 0 || (subject as Subject).State >= 2)
   Console.WriteLine("Another Concrete Observer: Reacted to the event.");
 }
}

#2 Web Application Project

Step 1 Create the interface and the service class files for the BLL. The interface class’ name sets “IObserverServices.” The service class’ name sets “ObserverServices.”

Step 2 Create the observer interface class files, which name sets “IObserver.” Create the concrete observer class file, which name sets “ConcreteObserver.”

Step 3 Create the subject interface class files. This class file’s name sets “ISubject.” Create the concrete subject class file which name sets “Subject.” In this sample, I create another class file that inherits the subject class file, which lets the concrete subject class object can a more extended application.

Step 4 Create the observer-related files, such as the controller part files, the view part files, etc.

Step 5 Register the Core’ project observer-related files in the web project’ startup.cs files.

// Observer
services.AddScoped(typeof(IObserverServices), typeof(ObserverServices));

• GitHub

Reference

• Refactoring.Guru – Observer
• C# Observer Design Pattern – Dofactory