C# 观察者模式

栏目总目录

---

概念

观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这种模式实现了表示层和数据逻辑层的分离，提高了系统的可维护性和可扩展性。

角色

在观察者模式中，通常包含以下几个角色：

1. Subject（主题）：主题对象，它管理着所有依赖于它的观察者对象，并在其状态发生改变时主动通知观察者对象。
2. Observer（观察者）：观察者对象，为那些在主题对象发生改变时需要获得通知的对象提供一个更新接口。
3. ConcreteSubject（具体主题）：具体主题类，它包含有经常发生改变的数据。
4. ConcreteObserver（具体观察者）：具体观察者类，实现观察者接口，以便得到主题状态的改变通知。

好处

1. 解耦：观察者和被观察者之间抽象耦合，降低了它们之间的依赖关系。
2. 支持广播通信：主题对象可以同时通知多个观察者对象。
3. 支持动态关联：观察者可以在运行时动态地订阅或取消订阅主题。

应用场景

1. 事件订阅系统：如新闻订阅、邮件订阅等，用户作为观察者订阅感兴趣的主题，当主题更新时，用户会收到通知。
2. GUI 编程：在图形用户界面编程中，观察者模式常用于实现视图与模型之间的同步更新。
3. 对象状态监控：在需要监控某个对象状态变化的场景中，可以使用观察者模式来实时获取状态变化信息。

示例代码

以下是一个简单的 C# 观察者模式实现示例：

using System;
using System.Collections.Generic;

// 主题接口
public interface ISubject
{
    void RegisterObserver(IObserver o);
    void RemoveObserver(IObserver o);
    void NotifyObservers();
}

// 观察者接口
public interface IObserver
{
    void Update(string message);
}

// 具体主题类
public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();
    private string subjectState;

    public string SubjectState
    {
        get { return subjectState; }
        set
        {
            subjectState = value;
            NotifyObservers();
        }
    }

    public void RegisterObserver(IObserver o)
    {
        observers.Add(o);
    }

    public void RemoveObserver(IObserver o)
    {
        observers.Remove(o);
    }

    public void NotifyObservers()
    {
        foreach (IObserver observer in observers)
        {
            observer.Update(subjectState);
        }
    }
}

// 具体观察者类
public class ConcreteObserver : IObserver
{
    private string name;
    private string observerState;

    public ConcreteObserver(string name)
    {
        this.name = name;
    }

    public void Update(string message)
    {
        observerState = message;
        Console.WriteLine($"Observer {name} received state: {message}");
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver("Observer1");
        ConcreteObserver observer2 = new ConcreteObserver("Observer2");

        subject.RegisterObserver(observer1);
        subject.RegisterObserver(observer2);

        subject.SubjectState = "Hello, Observers!";

        // 假设在某个时刻，我们不再需要 Observer2 的通知
        subject.RemoveObserver(observer2);

        subject.SubjectState = "Another update.";

        Console.ReadLine();
    }
}

用事件来实现观察者模式

当我们使用事件来实现观察者模式时，通常会有两个主要部分：一个被观察的对象（Subject），它包含一个或多个事件；以及观察者（Observer），它们订阅这些事件并在事件发生时执行相应的操作。以下是一个简单的使用事件来实现观察者模式的示例：

首先，我们定义观察者接口 IObserver：

public interface IObserver  
{  
    void OnEventRaised(string message);  
}

接下来，我们定义被观察对象 Subject，它包含一个事件 EventRaised 和管理观察者列表的功能：

using System;  
using System.Collections.Generic;  
  
public class Subject  
{  
    // 事件，当某件事情发生时触发  
    public event Action<string> EventRaised;  
  
    // 观察者列表  
    private List<IObserver> observers = new List<IObserver>();  
  
    // 订阅事件  
    public void Attach(IObserver observer)  
    {  
        observers.Add(observer);  
        // 当添加新的观察者时，直接订阅事件  
        EventRaised += observer.OnEventRaised;  
    }  
  
    // 取消订阅事件  
    public void Detach(IObserver observer)  
    {  
        observers.Remove(observer);  
        // 当移除观察者时，取消订阅事件  
        EventRaised -= observer.OnEventRaised;  
    }  
  
    // 通知所有观察者  
    protected virtual void NotifyObservers(string message)  
    {  
        // 触发事件  
        EventRaised?.Invoke(message);  
    }  
  
    // 当有事情发生时，调用此方法  
    public void RaiseEvent(string message)  
    {  
        NotifyObservers(message);  
    }  
}

现在，我们定义一个具体的观察者 ConcreteObserver 类，它实现了 IObserver 接口：

public class ConcreteObserver : IObserver  
{  
    private string name;  
  
    public ConcreteObserver(string name)  
    {  
        this.name = name;  
    }  
  
    public void OnEventRaised(string message)  
    {  
        Console.WriteLine("{0} received message: {1}", name, message);  
    }  
}

最后，我们使用这些类来演示观察者模式的使用：

class Program  
{  
    static void Main(string[] args)  
    {  
        // 创建被观察对象  
        Subject subject = new Subject();  
  
        // 创建观察者并订阅事件  
        IObserver observer1 = new ConcreteObserver("Observer 1");  
        IObserver observer2 = new ConcreteObserver("Observer 2");  
        subject.Attach(observer1);  
        subject.Attach(observer2);  
  
        // 触发事件，通知所有观察者  
        subject.RaiseEvent("Hello from Subject!");  
  
        // 取消一个观察者的订阅  
        subject.Detach(observer1);  
  
        // 再次触发事件，这次只有observer2会收到通知  
        subject.RaiseEvent("Another message from Subject!");  
    }  
}

在这个示例中，Subject 类包含了一个 EventRaised 事件，它用于通知观察者。观察者通过实现 IObserver 接口并定义 OnEventRaised 方法来响应事件。当 Subject 的 RaiseEvent 方法被调用时，它会通过触发 EventRaised 事件来通知所有已订阅的观察者。观察者通过调用 Attach 方法来订阅事件，并通过调用 Detach 方法来取消订阅。

这种实现方式使得 Subject 和 Observer 之间完全解耦，因为观察者通过事件与 Subject 进行交互，而不是直接调用 Subject 的方法。这提高了代码的灵活性和可维护性，使得添加新的观察者或修改事件的通知逻辑变得更加容易。

总结

观察者模式是一种非常有用的设计模式，它通过定义对象间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式广泛应用于各种需要事件监听和状态更新的场景中，提高了软件系统的灵活性和可维护性。