C# 设计模式系列教程-观察者模式

什么是观察者模式

观察者模式（Observer Pattern）是一种行为型设计模式，主要用于在对象之间建立一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于他的对象都会得到通知并自动更新。观察者模式又被称为发布-订阅模式。

观察者模式实现分析

在观察者模式中，有两种角色，分别是被观察者和观察者。被观察者有一个列表存储它的所有观察者，并且支持动态增加和删除观察者。当被观察者的状态发生改变时，它会循环通知它的所有观察者执行特定的操作。

观察者模式的优势

• 观察者模式降低了系统的耦合度。
• 观察者模式增强了程序的灵活性和扩展性。
• 观察者模式通过维护一对多的依赖关系，使得被观察者和观察者之间松散耦合。

观察者模式的应用场景

• 当一个对象的改变需要同时改变其他对象时，而又不知道有多少对象需要改变时，使用观察者模式。
• 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面时，使用观察者模式。
• 当一个对象必须通知其他对象，但是又不想和其他对象形成紧耦合关系时，使用观察者模式。

示例说明

示例1

下面我们来看一个简单的示例，模拟A公司发送消息到B公司，B公司接收消息的场景。

首先，我们定义一个抽象主题（Subject）接口，用于定义被观察者的行为。

public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void RemoveObserver(IObserver observer);
    void NotifyObservers(string message);
}

然后，我们定义一个具体主题（ConcreteSubject）类，实现抽象主题接口，并在其中增加一个用于存储观察者的列表。

public class ConcreteSubject : ISubject
{
    private List<IObserver> observers;

    public ConcreteSubject()
    {
        this.observers = new List<IObserver>();
    }

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

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

    public void NotifyObservers(string message)
    {
        foreach (var observer in observers)
        {
            observer.Update(message);
        }
    }
}

接下来，我们定义一个抽象观察者（Observer）接口，用于定义观察者的行为。

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

最后，我们定义一个具体观察者（ConcreteObserver）类，实现抽象观察者接口，并在其中实现观察者的行为。

public class ConcreteObserver : IObserver
{
    private string name;

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

    public void Update(string message)
    {
        Console.WriteLine("{0} received the message: {1}", name, message);
    }
}

现在，我们可以编写下面的代码进行测试：

class Program
{
    static void Main(string[] args)
    {
        // 创建被观察者对象
        ISubject subject = new ConcreteSubject();

        // 创建观察者对象
        IObserver observer1 = new ConcreteObserver("Observer1");
        IObserver observer2 = new ConcreteObserver("Observer2");

        // 注册观察者对象
        subject.RegisterObserver(observer1);
        subject.RegisterObserver(observer2);

        // 发布消息
        subject.NotifyObservers("A公司发布了新产品");

        // 移除观察者对象
        subject.RemoveObserver(observer2);

        // 发布消息
        subject.NotifyObservers("A公司发布了优惠信息");

        Console.ReadLine();
    }
}

当我们执行以上代码后，将得到以下输出结果：

Observer1 received the message: A公司发布了新产品
Observer2 received the message: A公司发布了新产品
Observer1 received the message: A公司发布了优惠信息

示例2

在上面的示例中，我们使用了类似广播的方式通知所有的观察者。在某些情况下，我们可能需要对每个观察者执行不同的操作。这时可以将观察者作为消息的一部分进行传递，如下所示：

public class ConcreteSubject : ISubject
{
    // ...

    public void NotifyObservers(string message, IObserver observer)
    {
        observer.Update(message);
    }
}

当我们需要通知观察者时，只需要将观察者作为参数传递给被观察者的 NotifyObservers 方法即可。在实际开发中，我们可以在 IObserver 接口中新增一个 Notify 方法，然后让具体观察者类实现该方法即可。

总结

观察者模式是一种非常实用的设计模式，它可以帮助我们解决对象之间紧耦合关系的问题。在实际开发中，我们可以将观察者模式应用到很多场景中，如事件处理、页面自动更新等。使用观察者模式可以使得程序具有更好的可维护性、可扩展性和可复用性。