What are the key concepts of the Observer design pattern in C#?

What are the key concepts of the Observer design pattern in C#?

The Observer design pattern is a behavioral pattern that defines a one-to-many dependency between objects. When one object changes state, all its dependents are notified and updated automatically.

Can you give me a simple code example of the Observer pattern in C#?

Sure! Here's a basic example:

using System;
using System.Collections.Generic;

// Subject
public class Subject
{
    private List<IObserver> observers = new List<IObserver>();

    public void Attach(IObserver observer) {
        observers.Add(observer);
    }

    public void Detach(IObserver observer) {
        observers.Remove(observer);
    }

    public void Notify() {
        foreach (var observer in observers) {
            observer.Update();
        }
    }
}

// Observer Interface
public interface IObserver
{
    void Update();
}

// Concrete Observer
public class ConcreteObserver : IObserver
{
    public void Update() {
        Console.WriteLine("Observer updated!");
    }
}

// Usage
public class Program
{
    public static void Main() {
        Subject subject = new Subject();
        ConcreteObserver observer = new ConcreteObserver();

        subject.Attach(observer);
        subject.Notify(); // Output: Observer updated!
    }
}

What are some real-world applications of the Observer pattern?

The Observer pattern is commonly used in event handling systems, such as GUI frameworks, where multiple components need to respond to user actions. It's also used in data binding scenarios, like in MVVM architecture, where changes in the model need to be reflected in the view.