Understanding the Observer Pattern in C#


Design patterns are important in software development as they help to create efficient, scalable, and maintainable code. The Observer Pattern is one such design pattern that plays a crucial role in establishing communication between objects. This pattern uses a publisher-subscriber model to enable a reliable means of notification. It ensures that when one object changes, these changes are communicated to multiple dependent objects. This makes the Observer Pattern a powerful tool for maintaining consistency across different parts of a software system.

What is Observer Pattern in C#?

At its core, the Observer Pattern defines a one-to-many relationship between objects, where one object (the subject or publisher) maintains a list of its dependents (observers or subscribers) and notifies them of any state changes. This decoupling enables a flexible and scalable system where the subject and observers operate independently.

Components of the Observer Pattern

  1. Subject (Publisher): This component maintains a list of observers and provides methods to register, remove, and notify observers.
  2. Observer (Subscriber): The observer defines an interface that subject objects use to notify changes. Multiple observers can subscribe to a subject.
  3. Concrete Subject: A concrete implementation of the subject that includes specific business logic and state changes.
  4. Concrete Observer: A concrete implementation of the observer interface that defines actions to take when notified of changes.

Implementing the Observer Pattern in C#

Let's delve into a basic implementation of the Observer Pattern using C#.

// Define the Observer interface
public interface IObserver
    void Update(string message);

// Define the Subject
public class Subject
    private List<IObserver> observers = new List<IObserver>();
    private string message;

    public void Attach(IObserver observer)

    public void Detach(IObserver observer)

    public void Notify()
        foreach (var observer in observers)

    public void ChangeState(string newMessage)
        message = newMessage;

// Implement Concrete Observer
public class ConcreteObserver : IObserver
    private string observerState;

    public void Update(string message)
        observerState = message;
        Console.WriteLine("Observer received state change: " + observerState);

// Usage
public class Program
    public static void Main(string[] args)
        Subject subject = new Subject();

        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();


        subject.ChangeState("New State!"); // Notifies observers


        subject.ChangeState("Updated State!"); // Only observer1 receives the update

Advantages of the Observer Pattern

  • Loose Coupling: Subjects and observers are decoupled, allowing changes in one to occur without affecting the other.
  • Scalability: Easy addition or removal of observers without modifying the subject.
  • Flexibility: Multiple observers can react independently to changes in the subject.


The Observer Pattern in C# provides an elegant solution for establishing communication between objects while maintaining flexibility and scalability in a system. Separating concerns and allowing objects to observe and react to changes independently, it fosters a robust and maintainable codebase. Incorporating this pattern into your designs can greatly enhance the flexibility and extensibility of your software architecture.

Similar Articles