C#设计模式之观察者模式实例讲解

概念介绍

观察者模式(Observer Pattern)是软件设计模式之一，它定义了对象之间的一种一对多的依赖关系，让多个观察者（Observers）对象同时监听某一个主题（Subject）对象。当这个主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新。

观察者模式中有两个重要的部分：Subject 主题和 Observer 观察者。Subject 主题内部维护了一个订阅者列表，观察者 Observer 将自己注册到 Subject 主题对象的订阅者列表中，当 Subject 主题内部变化时，就可以通知所有注册的观察者对象更新。

实现步骤

具体的实现步骤如下：

1. 定义 Subject 主题接口，包含注册、移除和通知订阅者等方法。
2. 定义 Observer 观察者接口，包含更新方法。
3. 实现具体的 Subject 主题类。
4. 实现具体的 Observer 观察者类。
5. 测试主题和观察者的交互。

示例说明

下面通过两个示例来演示观察者模式的使用方法。

示例一：银行利率变化

假设有一家银行，它的利率会时常更新，为了及时通知客户，银行创建了一个 Subject 主题类 Bank，客户作为观察者 Observer 订阅了该主题。

public interface IBank
{
    void Attach(ICustomer customer);   // 添加观察者
    void Detach(ICustomer customer);   // 移除观察者
    void Notify();                     // 通知观察者
    decimal InterestRate { get; set; } // 利率属性
}

public class Bank : IBank
{
    private List<ICustomer> _customers = new List<ICustomer>();
    private decimal _interestRate;

    public decimal InterestRate
    {
        get { return _interestRate; }
        set
        {
            if (_interestRate != value)
            {
                _interestRate = value;
                Notify(); // 通知观察者
            }
        }
    }

    public void Attach(ICustomer customer)
    {
        _customers.Add(customer);
    }

    public void Detach(ICustomer customer)
    {
        _customers.Remove(customer);
    }

    public void Notify()
    {
        foreach (var customer in _customers)
        {
            customer.Update(this); // 更新观察者状态
        }
    }
}

public interface ICustomer
{
    void Update(IBank bank); // 更新观察者状态
}

public class Customer : ICustomer
{
    private readonly string _name;

    public Customer(string name)
    {
        _name = name;
    }

    public void Update(IBank bank)
    {
        Console.WriteLine($"{_name} - 今日利率为 {bank.InterestRate}");
    }
}

在客户端代码中，银行利率发生变化时，会自动通知所有的客户：

static void Main(string[] args)
{
    IBank bank = new Bank();

    var customer1 = new Customer("小明");
    var customer2 = new Customer("小红");

    bank.Attach(customer1);
    bank.Attach(customer2);

    bank.InterestRate = 0.03m; // 利率变化导致通知观察者更新

    bank.Detach(customer2); // 移除一个观察者

    bank.InterestRate = 0.04m; // 利率变化导致通知观察者更新

    Console.ReadLine();
}

输出结果：

小明 - 今日利率为 0.03
小红 - 今日利率为 0.03
小明 - 今日利率为 0.04

示例二：微信公众号文章发布

假设有一家微信公众号，管理员发布了一篇文章，为了及时通知所有订阅者，微信公众号创建了一个 Subject 主题类 WeChat，订阅者作为观察者 Observer 订阅了该主题。

public interface IWeChat
{
    void Attach(ISubscriber subscriber); // 添加观察者
    void Detach(ISubscriber subscriber); // 移除观察者
    void Notify(string article); // 通知观察者
}

public class WeChat : IWeChat
{
    private readonly List<ISubscriber> _subscribers = new List<ISubscriber>();

    public void Attach(ISubscriber subscriber)
    {
        _subscribers.Add(subscriber);
    }

    public void Detach(ISubscriber subscriber)
    {
        _subscribers.Remove(subscriber);
    }

    public void Notify(string article)
    {
        foreach (var subscriber in _subscribers)
        {
            subscriber.Receive(article); // 更新观察者状态
        }
    }
}

public interface ISubscriber
{
    void Receive(string article); // 更新观察者状态
}

public class Subscriber : ISubscriber
{
    private readonly string _name;

    public Subscriber(string name)
    {
        _name = name;
    }

    public void Receive(string article)
    {
        Console.WriteLine($"{_name} - 收到新文章：{article}");
    }
}

在客户端代码中，当管理员发布一篇文章时，会自动通知所有订阅者：

static void Main(string[] args)
{
    IWeChat wechat = new WeChat();

    var subscriber1 = new Subscriber("小明");
    var subscriber2 = new Subscriber("小红");

    wechat.Attach(subscriber1);
    wechat.Attach(subscriber2);

    wechat.Notify("观察者模式实例讲解"); // 发布新文章导致通知观察者更新

    wechat.Detach(subscriber2); // 移除一个观察者

    wechat.Notify("微信公众号设计模式"); // 发布新文章导致通知观察者更新

    Console.ReadLine();
}

输出结果：

小明 - 收到新文章：观察者模式实例讲解
小红 - 收到新文章：观察者模式实例讲解
小明 - 收到新文章：微信公众号设计模式

总结

观察者模式是一种非常重要的设计模式，提供了一种松耦合的方式，使得被观察者和观察者之间变得灵活可扩展。在实际开发中，我们要善于运用设计模式来优化代码结构，提高代码重用性、可维护性和可测试性。