设计模式－观察者模式与委托

秒速五厘米 2022-02-03 14:29 211阅读 0赞

**目录**

观察者模式：

委托：

--------------------

### 观察者模式： ###

**使用场景：**

一：当一个对象的改变需要同时改变其他对象的时候。而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。

二：一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两者封装在独立的对象中，使它们各自独立地改变和复用。

**观察者模式：**定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NpZWxfWQ_size_16_color_FFFFFF_t_70][]

这样避免了前台和看股票观察者直接接触导致的双向耦合。而且可以随时添加通知者和观察者。

代码：

通知者接口：

interface Subject
        {
            void Attach(Observer observer);
            void Detach(Observer observer);
            void Notify();
            string SubjectState
            {
                get;
                set;
            }
        }

实现接口的老板

class Boss:Subject
        {
            //同事列表
            private IList<Observer> observers = new List<Observer>();
            private string action;
            //增加
            public void Attach(Observer observer)
            {
                observers.Add(observer);
            }
            //减少
            public void Detach(Observer observer)
            {
                observers.Remove(observer);
            }
            //通知
            public void Notify()
            {
                foreach (Observer o in observers)
                    o.Update();
            }
            //老板状态
            public string SubjectState
            {
                get { return action; }
                set { action = value; }
            }
        }

抽象观察者：

abstract class Observer
        {
            protected string name;
            protected Subject sub;
            //原来是“前台”，现改成“抽象通知者”
            public Observer(string name,Subject sub)
            {
                this.name = name;
                this.sub = sub;
            }
            public abstract void Update();
        }

看股票和NBA的同事：

//看股票的同事
        class StockObserver:Observer
        {
            public StockObserver(string name,Subject sub)
                :base (name,sub)
            { }
            public override void Update()
            {
                Console.WriteLine("{0} {1} 关闭股票行情，继续工作！",sub.SubjectState,name);
            }
        }
        //看NBA的同事
        class NBAObserver : Observer
        {
            public NBAObserver(string name, Subject sub)
                : base(name, sub)
            { }
            public override void Update()
            {
                Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！", sub.SubjectState, name);
            }
        }

客户端：

static void Main(string[] args)
            {
                Boss huhansan = new Boss();
                //看股票的同事
                StockObserver tongshi1 = new StockObserver("韦观察", huhansan);
                //看NBA的同事
                NBAObserver tongshi2 = new NBAObserver("以观察", huhansan);
                huhansan.Attach(tongshi1);
                huhansan.Attach(tongshi2);
                huhansan.Detach(tongshi1);
                //老板回来
                huhansan.SubjectState = "我胡汉三回来了！";
                //发出通知
                huhansan.Notify();
                Console.ReadKey();
            }

运行结果：

![20190509193419534.png][]

**特点： **

将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护，扩展和重用都带来不便。

**缺点：**

1、看股票观察者和看NBA观察者没有各自适合的方法。

2、抽象通知者还是依赖抽象观察者。 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

我们可以通过**委托**来克服它的缺点。

总的来说，观察者模式就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使各自的变化都不会影响另一边的变化。

### 委托： ###

**委托**就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的‘类’，委托的实例将代表一个具体的函数。

**代码：**

看股票的同事，方法“更新”改为“关闭股票程序”。解决缺点1.

//关闭股票行情
            public void CloseStockMarket()
            {
                Console.WriteLine("{0} {1} 关闭股票行情，继续工作！",sub.SubjectState,name);
            }

看NBA的同事，方法“更新”改为”关闭NBA直播“

//关闭NBA直播
            public void CloseNBADirectSeeding()
            {
                Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！",sub.SubjectState,name);
            }

抽象通知者：由于不希望依赖“抽象观察者”，所以“增加”和“减少”的方法也就没有必要了（抽象观察者已经不存在了）。

interface Subject
        {
            void Notify();
            string SubjectState
            {
                get;
                set;
            }
        }

声明一个委托，名叫“EventHandler”无参数，无返回值：

delegate void EventHandler();

“老板”类和“秘书”类：声明EventHandler的委托事件，名叫Update。

class Boss:Subject
        {
            //声明一件事Update,类型为委托EventHandler
            public event EventHandler Update;
            private string action;
            public void Notify()
            {//在访问“通知”方法时，调用更新。
                Update();
            }
            public string SubjectState
            {
                get { return action; }
                set { action = value; }
            }
        }
        class Secretary:Subject
        {
            public event EventHandler Update;
            private string action;
            public void Notify()
            {
                Update();
            }
            public string SubjectState
            {
                get { return action; }
                set { action = value; }
            }
        }

**客户端代码：**将“看股票者”的“关闭股票程序”方法和“看NBA者”的“关闭NBA直播”方法挂钩到“老板”的“更新”上，也就是两种不同类型的不同方法，委托给“老板”类“更新”了。即这次是子类分别有不同的方法，通过老板的“更新”方法，委托来实现。第一种代码是通过老板的增加，减少，通知等方法来发出通知，实现子类共同的“更新”方法。

将：

huhansan.Attach(tongshi1);
                huhansan.Attach(tongshi2);
                huhansan.Detach(tongshi1);

替换为：

huhansan.Update += new EventHandler(tongshi1.CloseStockMarket);
                huhansan.Update+= new EventHandler(tongshi2.CloseNBADirectSeeding);

![20190509205556615.png][]

**分析：**

一个委托可以搭载多个方法，所有方法被依次唤起。可以使得委托对象所搭载的方法并不需要属于同一个类。如这个例子中，两个子类两个不同的方法，用Boss进行搭载。

委托对象所搭载的所有方法必须具有相同的原形和形式，也就是拥有相同的参数列表和返回值类型。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NpZWxfWQ_size_16_color_FFFFFF_t_70]: /images/20220203/c350ed0bbd174db78b5b75efd33a12fb.png
[20190509193419534.png]: /images/20220203/397bba6676ac4acd95f673b5f3410336.png
[20190509205556615.png]: /images/20220203/a4784a9db85d4ec1bf834b02a15dd6fb.png