Observer Pattern in C#

The Observer Pattern lets one object (the subject) notify other objects (observers) when its state changes. Observers subscribe to the subject and automatically receive updates — without being tightly coupled.

Real-Life Analogy: YouTube Subscriber

Imagine you subscribe to a YouTube channel. When the channel uploads a new video, all subscribers get notified. The creator doesn't message you directly — YouTube handles distributing updates to everyone who follows the channel.

That's how the Observer Pattern works. A subject manages a list of observers and notifies them whenever something changes.

Benefits of Observer Pattern

This pattern promotes loose coupling between the object that changes (the subject) and the objects that react (observers). It's perfect for building reactive or event-driven systems.

It also helps when multiple objects need to react to a shared data source.

• Supports event-driven design
• Decouples data producers and consumers
• Makes systems flexible and extensible

When Should You Use It?

Use the Observer Pattern when you want several objects to automatically know when another object changes. It's ideal when you want to avoid polling or manual coordination.

It fits when:

• Multiple parts of your app depend on shared data
• You want to keep objects loosely connected
• You need a publish/subscribe model

When Not to Use It: Avoid it if all changes only matter to one object — or if managing observers adds unnecessary complexity.

What to Implement

To build this pattern, you need:

A subject that keeps track of subscribers and notifies them, and observers that implement a method to receive updates.

• Subject Interface: Lets observers subscribe/unsubscribe
• Observer Interface: Declares the update method
• Concrete Subject: Stores data and triggers notifications
• Concrete Observers: Respond to updates

How It Works in C#

// Observer Interface
public interface ISubscriber
{
    void Update(string videoTitle);
}

// Subject Interface
public interface IChannel
{
    void Subscribe(ISubscriber subscriber);
    void Unsubscribe(ISubscriber subscriber);
    void Notify(string videoTitle);
}

// Concrete Subject
public class YouTubeChannel : IChannel
{
    private readonly List<ISubscriber> subscribers = new();

    public void Subscribe(ISubscriber subscriber) => subscribers.Add(subscriber);
    public void Unsubscribe(ISubscriber subscriber) => subscribers.Remove(subscriber);

    public void Notify(string videoTitle)
    {
        foreach (var s in subscribers)
            s.Update(videoTitle);
    }

    public void Upload(string title)
    {
        Console.WriteLine($""Uploaded: {title}"");
        Notify(title);
    }
}

// Concrete Observer
public class Subscriber : ISubscriber
{
    private readonly string name;

    public Subscriber(string name) => this.name = name;

    public void Update(string videoTitle)
    {
        Console.WriteLine($""{name} got notified: {videoTitle}"");
    }
}

Usage:

var channel = new YouTubeChannel();
var alice = new Subscriber("Alice");
var bob = new Subscriber("Bob");

channel.Subscribe(alice);
channel.Subscribe(bob);

channel.Upload("Observer Pattern Explained!");

Final Thoughts

The Observer Pattern helps you build responsive systems. Instead of checking for changes, your app reacts to them as they happen.

Whether it's notifications, news alerts, or stock prices — this pattern ensures every subscriber stays updated without manual effort.