您会如何用初学者语言描述观察者模式？

Question

目前，我的理解水平低于网络上所有关于观察者模式的编码示例。 我将其简单地理解为几乎是一个订阅，当委托注册的更改发生时，它会更新所有其他事件。 然而，我对好处和用途的真正理解非常不稳定。 我已经做了一些谷歌搜索，但大多数都超出了我的理解水平。

我正在尝试通过当前的作业来实现此模式，并且要真正使我的项目有意义，需要更好地理解该模式本身，也许还需要一个示例来了解其用途。 我不想强迫这种模式只是为了提交，我需要理解目的并相应地开发我的方法，以便它实际上达到良好的目的。 我的文字并没有真正讨论它，只是在一句话中提到它。 MSDN 对我来说很难理解，因为我是这方面的初学者，而且它似乎是一个高级主题。

您会如何向初学者描述这个观察者模式及其在 C# 中的用途？ 例如，请保持代码非常简单，这样我比复杂的代码片段更能理解其目的。 我正在尝试通过一些简单的文本框字符串操作来有效地使用它，并使用委托来完成我的作业，因此指针会有所帮助！

Answer 1

我能想到的最好的例子是邮件列表（作为示例）。

作为观察者，您订阅邮件列表并观察该列表。 当您不再对该列表感兴趣时，您可以取消订阅。

这个概念就是观察者模式。 涉及两个或多个类。 一个或多个类订阅发布者类（有不同的名称），然后第一个类（以及每个订阅类）将在发布者需要时收到通知。

我就是这样向我的妻子解释的，她经常听我对编程和设计理论的咆哮。 这对她来说很有意义。 我意识到这对您来说可能太简单了，但这是一个好的开始...

问候，
坦率

Answer 2

查看“首先：设计模式”，了解一些真正令人惊叹的内容额头容易遵循主要模式的描述。

对于观察者来说，重要的是要理解它描述了一对多关系，并使用订阅模型来通知其他类何时发生更改。 RSS、Atom 和 Twitter 都是按照这些思路工作的。

Answer 3

观察者想知道什么时候发生变化，因此它订阅了主题。 主体不认识观察者。 这是重要的部分。 主题只是定义观察者需要提供的接口（或委托），并允许注册。

简而言之：观察者模式允许从一个主题调用您的观察者，该主题不关心观察者是谁以及它是否存在。

Answer 4

有两个对象NOTIFIER和OBSERVER。 NOTIFIER 对 OBSERVER 一无所知，而 OBSERVER 知道 NOTIFER 实现了一个事件。

观察者使用事件来通知其他对象发生了某些事情。 简单来说，事件就是方法列表。 因为 OBSERVER 希望在发生某事时得到通知，所以 OBSERVER 在 NOTIFER 事件中添加了一个方法，如果发生某事则应调用该方法。

因此，如果发生这种情况，NOTIFIER 会发布此事件，NOTIFIER 只是遍历方法列表并调用它们。 当调用 OBSERVER 添加的方法时，OBSERVER 知道事情发生了，并且可以执行这种情况下所需的操作。

下面是一个带有 ValueChanged() 事件的示例通知程序类。

// Declare how a method must look in order to be used as an event handler.
public delegate void ValueChangedHandler(Notifier sender, Int32 oldValue, Int32 newValue);

public class Notifier
{
    // Constructor with an instance name.
    public Notifier(String name)
    {
        this.Name = name;
    }
    public String Name { get; private set; }

    // The event that is raised when ChangeValue() changes the
    // private field value.
    public event ValueChangedHandler ValueChanged;

    // A method that modifies the private field value and
    // notifies observers by raising the ValueChanged event.
    public void ChangeValue(Int32 newValue)
    {
        // Check if value really changes.
        if (this.value != newValue)
        {
            // Safe the old value.
            Int32 oldValue = this.value;

            // Change the value.
            this.value = newValue;

            // Raise the ValueChanged event.
            this.OnValueChanged(oldValue, newValue);
        }
    }

    private Int32 value = 0;

    // Raises the ValueChanged event.
    private void OnValueChanged(Int32 oldValue, Int32 newValue)
    {
        // Copy the event handlers - this is for thread safty to
        // avoid that somebody changes the handler to null after
        // we checked that it is not null but before we called
        // the handler.
        ValueChangedHandler valueChangedHandler = this.ValueChanged;

        // Check if we must notify anybody.
        if (valueChangedHandler != null)
        {
            // Call all methods added to this event.
            valueChangedHandler(this, oldValue, newValue);
        }
    }
}

这是一个观察者类的示例。

public class Observer
{
    // Constructor with an instance name.
    public Observer(String name)
    {
        this.Name = name;
    }
    public String Name { get; private set; }

    // The method to be registered as event handler.
    public void NotifierValueChanged(Notifier sender, Int32 oldValue, Int32 newValue)
    {
        Console.WriteLine(String.Format("{0}: The value of {1} changed from {2} to {3}.", this.Name, sender.Name, oldValue, newValue));
    }
}

一个小型测试应用程序。

class Program
{
    static void Main(string[] args)
    {
        // Create two notifiers - Notifier A and Notifier B.
        Notifier notifierA = new Notifier("Notifier A");
        Notifier notifierB = new Notifier("Notifier B");

        // Create two observers - Observer X and Observer Y.
        Observer observerX = new Observer("Observer X");
        Observer observerY = new Observer("Observer Y");

        // Observer X subscribes the ValueChanged() event of Notifier A.
        notifierA.ValueChanged += observerX.NotifierValueChanged;

        // Observer Y subscribes the ValueChanged() event of Notifier A and B.
        notifierA.ValueChanged += observerY.NotifierValueChanged;
        notifierB.ValueChanged += observerY.NotifierValueChanged;

        // Change the value of Notifier A - this will notify Observer X and Y.
        notifierA.ChangeValue(123);

        // Change the value of Notifier B - this will only notify Observer Y.
        notifierB.ChangeValue(999);

        // This will not notify anybody because the value is already 123.
        notifierA.ChangeValue(123);

        // This will not notify Observer X and Y again.
        notifierA.ChangeValue(1);
    }
}

输出如下。

Observer X: The value of Notifier A changed from 0 to 123.
Observer Y: The value of Notifier A changed from 0 to 123.
Observer Y: The value of Notifier B changed from 0 to 999.
Observer X: The value of Notifier A changed from 123 to 1.
Observer Y: The value of Notifier A changed from 123 to 1.

---

为了理解委托类型，我将它们与类类型进行比较。

public class Example
{
   public void DoSomething(String text)
   {
      Console.WriteLine(
         "Doing something with '" + text + "'.");
   }

   public void DoSomethingElse(Int32 number)
   {
      Console.WriteLine(
         "Doing something with '" + number.ToString() + "'.");
   }
}

我们定义了一个带有两个方法的简单类Example。 现在我们可以使用这个类类型了。

Example example = new Example();

虽然这有效，但以下不起作用，因为类型不匹配。 您会收到编译器错误。

Example example = new List<String>();

我们可以使用变量example。

example.DoSomething("some text");

现在与委托类型相同。 首先我们定义一个委托类型——这只是一个类型定义，就像之前的类定义一样。

public delegate void MyDelegate(String text);

现在我们可以使用委托类型，但是我们不能将普通数据存储在委托类型变量中，而是存储在方法中。

MyDelegate method = example.DoSomething;

我们现在已经存储了对象 example 的方法 DoSomething()。 以下代码不起作用，因为我们将 MyDelegate 定义为接受一个字符串参数并返回 void 的委托。 DoSomethingElse 返回 void 但采用整数参数，因此您会收到编译器错误。

MyDelegate method = example.DoSomethingElse;

最后你可以使用变量方法。 您无法执行数据操作，因为变量不存储数据，而是存储方法。 但您可以调用存储在变量中的方法。

method("Doing stuff with delegates.");

这会调用我们存储在变量中的方法 - example.DoSomething()。

Answer 5

观察者模式就像它听起来的那样——

它是某些对象观察对象、观察其变化的一种方式。

在 C# 中，这变得有些简单，因为事件基本上是实现观察者模式的特定于语言的方法。 如果您曾经使用过事件，那么您就使用过观察者模式。

在其他语言中，这不是内置的，因此已经进行了许多尝试来形式化处理此问题的方法。

Answer 6

观察者就像一条直接的通讯线路。 当您生病时，不要让所有亲戚打电话询问您的情况，而是写一张卡片，每个感兴趣的人都会收到它（或副本）。 当你病情好转时，你会寄出一张卡片。 当你绊倒脚趾时，你就发出了一张卡片。 当你得到 A 时，你会发出一张卡片。

任何关心的人都会进入您的群发邮件列表，并可以按照他们认为合适的方式进行回复。

这种依赖关系对于 UI 来说非常有用。 如果我有一个缓慢的进程（例如），即使取得进展，它也可能会触发。 进度条元素可以观察并更新其覆盖范围。 OK 按钮可以观察到这一点并在 100% 时变为活动状态。 光标可以观察到动画，直到进度达到 100%。 这些观察者都不需要互相了解。 此外，这些元素都不需要严格了解驱动它们的因素。

Answer 7

这种模式即使不是最基本的模式，也可能是最基本的模式之一。

涉及两个“人”； 发布者和订阅者/观察者。

观察者只需要求发布者在有“新闻”时通知他。这里的新闻可以是任何重要的东西。 它可以是空气的温度，可以是网站上的新帖子，也可以是一天中的时间。

Answer 8

您遇到的麻烦可能是定义正确的接口。 该接口定义了订阅者和发布者之间的交互。

C# WinForms 应用程序

首先创建一个像这样的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.Run(new Form1());
        }
    }

    interface IObserver
    {
        void Refresh(List<string> DisplayList);
    }

    class ObserverList : List<IObserver>
    {
        public void Refresh(List<String> DisplayList)
        {
            foreach (IObserver tItem in this)
            {
                tItem.Refresh(DisplayList);
            }
        }

    }
}

Setup Program.cs我们在这里做了两件事。 第一个是订阅者将实现的接口。 然后是发布者保存所有订阅者的列表。

然后制作带有两个按钮的表单一，一个标记为“表单 2”，另一个标记为“表单 3”。然后添加一个文本框，然后添加另一个标记为“添加”的按钮。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        private List<string> DataList= new List<string>();
        private ObserverList MyObservers = new ObserverList();
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 frmNewForm = new Form2();
            MyObservers.Add(frmNewForm);
            frmNewForm.Show();
            MyObservers.Refresh(DataList);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Form3 frmNewForm = new Form3();
            MyObservers.Add(frmNewForm);
            frmNewForm.Show();
            MyObservers.Refresh(DataList);

        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)
        {
            DataList.Add(textBox1.Text);
            MyObservers.Refresh(DataList);
            textBox1.Text = "";
        }

    }
}

我特意设置了 Form2 按钮和 FOrm3 按钮，以便为每种类型的表单制作多个副本。 例如，您可以一次有十二个。

您会注意到，创建每个表单后，我将其放入观察者列表中。 我能够做到这一点是因为 Form2 和 Form3 都实现了 IObserver。 显示表单后，我在观察者列表上调用刷新，以便使用最新数据更新新表单。 请注意，我可以将其转换为 IObserver 变量并仅更新该形式。 我试图尽可能简短。

然后，对于“添加”按钮“Button3”，我从文本框中提取文本，将其存储在我的 DataList 中，然后刷新所有观察者。

然后制作Form2。 添加一个列表框和以下代码。

使用系统；

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form2 : Form,IObserver
    {
        public Form2()
        {
            InitializeComponent();
        }

        private void Form2_Load(object sender, EventArgs e)
        {

        }

        void IObserver.Refresh(List<string> DisplayList)
        {
            this.listBox1.Items.Clear();
            foreach (string s in DisplayList)
            {
                this.listBox1.Items.Add(s);
            }
            this.listBox1.Refresh();
        }

    }
}

然后添加 Form3（一个组合框）并添加以下代码。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form3 : Form,IObserver
    {
        public Form3()
        {
            InitializeComponent();
        }

        private void Form3_Load(object sender, EventArgs e)
        {

        }
        void IObserver.Refresh(List<string> DisplayList)
        {
            this.comboBox1.Items.Clear();
            foreach (string s in DisplayList)
            {
                this.comboBox1.Items.Add(s);
            }
            this.comboBox1.Refresh();
        }
    }
}

您会注意到，每个表单实现 IObserver 接口的刷新方法略有不同。 一个用于列表框，另一个用于组合框。 接口的使用是这里的关键要素。

在现实世界的应用中，这个例子会更加复杂。 例如，不要在刷新界面中传递字符串列表。 它不会有任何参数。 相反，发布者（本例中为 Form1）将实现发布者接口，并在观察者初始化时向观察者注册自身。 每个观察者都能够在其初始化例程中接受发布者。 然后，当刷新时，它将通过通过接口公开的方法将字符串列表从发布者中拉出。

对于具有多种数据类型的更复杂的应用程序，这允许您自定义实现 IObserver 的表单从发布者中提取哪些数据。

当然，如果您只希望观察者能够显示字符串列表或特定数据。 然后将其作为参数的一部分传递。 接口明确了每一层想要做什么。 这样 5 年后，您就可以查看代码并了解代码“哦，它在做什么”。

Answer 9

_{（来源：headfirstlabs.com）}
正如所说，查看“Head First：设计模式”，他们也有一些有关本书的论坛 和 设计冥想。

观察者模式遵循好莱坞原则“不要打电话给我们，我们会打电话给你”

模式的好网站
http://www.dofactory.com/Patterns/PatternObserver.aspx

Answer 10

用最简单的术语来说，有两个组件：观察者和被观察者。

在外部，被观察者需要一种添加（注册）和删除观察者的方法。
在内部，被观察者需要一个已注册观察者的列表。

观察者需要一个公共方法，例如 Notify() 或 Notify(params)。

每当被观察者发生特定事件时，它将循环遍历列表并对每个注册的观察者调用 Notify()。

在最简单的情况下，这是一个简单的通知，内容是“嘿，观察者，我的数据已更改，请过来刷新一下”
在更复杂的版本中，参数可以让观察者知道发生了什么变化。

在模型-视图-控制器中，被观察者通常是一个实体对象——保存数据的东西。 控制者就是观察者。 它监视模型中的更改，并告诉视图如果对更改感兴趣则自行更新。

Java 事件侦听器是此模式的现实实现。

Answer 11

想象一下，您有一个想要观察其行为（或状态）的对象。 例如，当字段 A 达到值 10 时，您希望获得有关该事件的通知，而无需实际耦合您想要观察的这个复杂对象的实现细节。
你定义一个接口，称之为 Observable 并让你的目标实现这个接口，它应该至少有两个方法来注册和注销一个观察者，而观察者又是当字段 A 达到 10 时将被观察者调用的对象。你的观察者只需调用 Observable 进行注册（并在完成后取消注册）。 Observable 通常会维护一个观察者列表并立即通知他们，或者根据您的需要通知他们。 它也可以同步或异步完成，这取决于你。 这是非常简单的解释，无需编写代码。 一旦您理解了它，实现就可以在细节上有所不同，以满足您的特定需求。

Answer 12

观察者（发布/订阅）

当对象更改状态时，它会通知在运行时已注册其兴趣的其他对象。
通知对象（发布者）向其所有观察者（订阅者）发送事件（发布）。

Answer 13

一句话：

一个对象（主题）允许其他对象（观察者）注册通知。

实际示例：

假设您有一个应用程序，并且希望让其他开发人员构建插件。

您可以创建一个 PluginSubject 类，并在其上放置一个名为 NotifyOrderCreated 的方法。 每当在订单屏幕上创建新订单时，它都会调用 PluginSubject.NotifyOrderCreated。

当发生这种情况时，PluginSubject 会获取 PluginObserver 的列表，并对每个 PluginObserver 调用 PluginObserver.Notify，并传入描述该事件的消息。

这使得一些非常巧妙的功能成为可能。

比你想知道的更多：

我实际上最近这样做了，所以我将更深入地研究这个例子 - 如果你需要你的观察者实现一个特殊的接口，比如说IPluginObserver，你可以使用反射遍历程序集中的类型并动态实例化插件。

然后，您可以允许用户注册自己的程序集（您必须在某处存储程序集名称列表，然后遍历它），然后，您就获得了可扩展性！

Answer 14

观察者是一种解耦的手段，即松开两个对象之间的联系。 您想要这样，因为它使您的代码更整洁且更易于维护。 这几乎是所有设计模式的目标：更易于阅读，更易于维护代码。

在此模式中，您有两个类、两个对象：发布者和观察者。 Publisher 是一个实际上做了一些工作的类，然后它经常会调用任何观察者的方法来告诉他们这件事。 它知道要调用哪些类，因为它保留了订阅的观察者列表。

因此，您的发布商可能看起来像这样：

class Publisher
{
    List<Observer> observers = new List<Observer>();

public Add(Observer o)
{
    observers.Add(o);
}

private AlertObservers()
{
    foreach(Observer o in observers)
    {
        o.Alert();
    }
}

发布商确实完成了大部分工作。 观察者所需要做的就是添加到列表中并实现被调用的方法。 就像这样：

class Observer
{
    public Observer(Publisher pub)
    {
        pub.Add(this);
    }

    public Alert()
    {
        System.Console.WriteLine("Oh no, stuff is happening!");
    }
}

这是关于它如何工作的一个非常简单的想法。 现在，为什么它有价值？ 看起来耦合得很好吧？ 原因之一是因为我不使用接口，这将允许我设置许多具有观察者功能的类，并且发布者不需要了解有关它们的更多信息，除了它们可以接收 Alert() 调用之外。 另请注意，发布者将尝试对其拥有的任何和所有观察者调用警报，即使它没有观察者。

现在，在 C# 世界中，该语言通过其 Event 对象拥有此模式的内置版本。 事件非常强大，并且利用委托，这是一种在另一个方法调用中将方法作为参数传递的方式。 它们允许一些严重的脱钩，但我会把它留到一个新问题。

Answer 15

很少有实时示例：

1. 报纸/杂志/邮件列表
   订阅或任何一般订阅
2. 在 MS Office 中标记同事
   沟通者
3. 推特

Answer 16

那些认为 .NET 中的事件实际上是观察者模式的实现的人并没有拉动你的链条；他们只是在说。 这是真的。 至于它实际上是如何工作的，无论是从高层次的角度还是从更多特定于实现的细节来看，我将使用一个类比。

想想报纸出版商。 用面向对象编程的术语来说，我们可能会认为报纸是一个可观察的东西。 但它是如何运作的呢？ 显然，报纸本身的实施细节（也就是说，在这个类比中，记者、作家、编辑等都在办公室工作以整理报纸）并没有公开曝光。 人们（观察员）不会聚集在一起观看报纸出版商的员工工作。 他们不能这样做，因为没有适当的协议（或接口）来做到这一点。

这就是您观察（即阅读）报纸的方式：您订阅它。 你把你的名字列入该报纸的订阅者名单上，然后出版商就会知道每天早上将一份报纸送到你家门口。 如果您不想再观察（阅读）它，您可以取消订阅； 您的名字将从该列表中删除。

现在，这似乎是一个抽象的类比； 但它实际上与 .NET 事件的工作方式几乎完美平行。

给定一些旨在可观察的类，其实现通常不需要为公众所知。 然而，它会向公众公开一种特定类型的接口，而该接口就是一个事件。 想要观察此事件的代码本质上将自己注册为订阅者：

// please deliver this event to my doorstep
myObject.SomeEvent += myEventHandler;

当相同的代码决定不再希望收到此事件的通知时，它会取消订阅：

// cancel my subscription
myObject.SomeEvent -= myEventHandler;

现在快速讨论委托以及此代码的实际工作原理。 您可能知道也可能不知道，委托本质上是一个存储方法地址的变量。 通常，此变量具有类型 - 就像声明为 int、double、string 等的 value 变量一样都有类型。 对于委托类型，此类型由方法的签名定义； 即它的参数和它的返回值。 特定类型的委托可以指向执行任何操作的任何方法，只要该方法具有适当的签名即可。

回到报纸的类比：为了成功订阅报纸，您必须实际上遵循特定的模式。 具体来说，您需要提供要将报纸投递到的有效地址。 你不能只是说：“是的，将其发送给丹。” 你不能说：“我要一个培根芝士汉堡。” 您必须向出版商提供他们可以有意义地合作的信息。 在 .NET 事件领域，这意味着需要提供具有正确签名的事件处理程序。

在大多数情况下，此签名最终会成为如下所示的某种方法：

public void SomeEventHandler(object sender, EventArgs e) {
    // anything could go in here
}

上面的方法可以存储在 EventHandler 类型的委托变量中。 对于更具体的情况，有通用的 EventHandler 委托类型，它描述了与上面类似的方法，但具有某种派生类型的 e 参数来自 EventArgs。

请记住，委托实际上是指向方法的变量，因此在 .NET 事件和报纸订阅之间建立最终联系并不困难。 事件的实现方式是通过委托列表，可以向其中添加或删除项目。 这实际上就像报纸出版商的订阅者名单，每天早上分发报纸时，每个订阅者都会收到一份副本。

不管怎样，希望这能帮助您在某种程度上了解观察者模式。 当然，这种模式还有许多其他类型的实现，但 .NET 事件是大多数 .NET 开发人员都熟悉的范例，因此我认为这是一个很好的起点，可以加深人们的理解。