C#委托和事件實作觀察者模式

需求背景

   貓叫觸發一系列的動作或者說觸發一系列事件，貓叫導致狗叫，小孩哭，Mom跑，

代碼結構申明

 1     /// <summary>
 2     /// 介面類
 3     /// </summary>
 4     public interface IObeject
 5     {
 6         /// <summary>
 7         /// 提供該方法執行一系列繼承自該介面的類行為
 8         /// </summary>
 9         void DoAction();
10     }

 1     /// <summary>
 2     /// 狗類
 3     /// </summary>
 4     public class Dog : IObeject
 5     {
 6         public void DoAction()
 7         {
 8             this.Wang();
 9         }
10         /// <summary>
11         /// 狗叫
12         /// </summary>
13         public void Wang() {
14             Console.WriteLine("狗叫了...");
15         }
16     }

 1     /// <summary>
 2     /// 孩子類
 3     /// </summary>
 4     public class Baby : IObeject
 5     {
 6         public void DoAction()
 7         {
 8             this.Cry();
 9         }
10         /// <summary>
11         /// 小孩嚇哭了
12         /// </summary>
13         public void Cry() {
14             Console.WriteLine("小孩嚇哭了");
15         }
16 
17     }

    /// <summary>
    /// Mom類
    /// </summary>
    public class Mom : IObeject
    {
        public void DoAction()
        {
            this.Run();
        }
        /// <summary>
        /// 媽媽跑
        /// </summary>
        public void Run() {
            Console.WriteLine("媽媽著急了，Mom Run...");
        }
    }

 1     /// <summary>
 2     /// 貓類
 3     /// </summary>
 4     public class Cat
 5     {
 6         /// <summary>
 7         /// Cat類依賴了多種型別，任何貓類依賴的型別變化都與貓有關，貓類甚至還要控制事件的執行順序，
 8         /// 如果事件需要調整順序，或者貓依賴的類發生變化都得修改貓類的代碼，類與類之間的關系嚴重耦合，且職責不單一
 9         /// 實際上不該如此，貓就是貓，貓只負責Miao，貓只做自己的事，別的事與我無關，需求就是貓Miao了一聲，觸發一系列
10         /// 動作，至于觸發什么動作，與貓無關，
11         /// </summary>
12         public void Miao()
13         {
14             Console.WriteLine("貓叫了一聲...");
15             new Dog().Wang();
16             new Baby().Cry();
17             new Mom().Run();
18         }
19 
20         private IList<IObeject> _ObserverList = new List<IObeject>();
21 
22         public void AddObserver(IObeject obeserver) {
23             this._ObserverList.Add(obeserver);
24         }
25 
26         public void MiaoObserver() {
27 
28             foreach (var _obeserver in _ObserverList)
29             {
30                 _obeserver?.DoAction();
31             }
32         }
33 
34         #region 使用委托
35         public Action CatMiaoAction;
36 
37         public void MiaoDelegate() {
38 
39             this.CatMiaoAction?.Invoke();
40         }
41         #endregion
42 
43         #region 使用事件
44         /// <summary>
45         /// 什么是事件？事件是委托的一個實體，如Student的一個實體是張三，并且帶有event關鍵字修飾，事件是一種更安全的特殊委托
46         /// 只能在事件所在的類內部對其賦值和呼叫（invoke();),不能在外部對其賦值和呼叫，即使是子類，
47         /// </summary>
48         public event Action CatMiaoActionEvent;
49 
50         public void MiaoDelegateHandler()
51         {
52            //this.CatMiaoActionEvent = null;//編譯可以通過
53            this.CatMiaoActionEvent?.Invoke();//編譯可以通過
54         }
55         #endregion
56     }
57 
58     public class MiniCat : Cat
59     {
60         public void Do()
61         {
62             //this.CatMiaoActionEvent = null;//即使是子類，編譯不通過,不能賦值
63             //this.CatMiaoActionEvent?.invoke();//即使是子類，編譯不通過，不能呼叫
64         }
65     }

 1     static void Main(string[] args)
 2         {
 3             {
 4                 new Cat().Miao();
 5             }
 6             {
 7                 //去除了貓類對其它類的依賴，把依賴通過抽象轉移到外部，事件的觸發邏輯交給呼叫者，與貓
 8                 //無關，貓作為事件發布者，這是一種觀察者模式的運用
 9                 Cat cat = new Cat();
10                 cat.AddObserver(new Dog());
11                 cat.AddObserver(new Baby());
12                 cat.AddObserver(new Mom());
13                 cat.MiaoObserver();
14                 Console.WriteLine("**********");
15             }
16             {
17                 //使用委托和事件的方式解決該問題,去除了Cat的依賴，Cat穩定了,還可以有多個Cat.CatMiaoAction的實體
18                 Cat cat = new Cat();
19                 cat.CatMiaoAction += new Dog().Wang;
20                 cat.CatMiaoAction += new Baby().Cry;
21                 cat.CatMiaoAction += new Mom().Run;
22                 cat.MiaoDelegate();
23                 Console.WriteLine("**********");
24             }
25             {
26                 //使用委托和事件的方式解決該問題,去除了Cat的依賴，Cat穩定了,還可以有多個Cat.CatMiaoActionEvent的實體
27                 Cat cat = new Cat();
28                 cat.CatMiaoActionEvent += new Dog().Wang;
29                 cat.CatMiaoActionEvent += new Baby().Cry;
30                 cat.CatMiaoActionEvent += new Mom().Run;
31                 cat.MiaoDelegateHandler();
32                 Console.WriteLine("**********");
33             }
34             Console.ReadLine();
35         }

標籤：C#

上一篇：創建型設計模式總結

下一篇：例外System.AccessViolationException的處理方式