觀察者模式，又叫釋出-訂閱模式，定義了一種一對多的依賴關係，讓多個觀察者物件同事監聽某一個主題物件，這個主體物件在狀態發生變化時，會通知所有觀察者物件，使它們能夠自動更新自己。

結構圖：

實現程式碼：

 1     /// <summary>
 2     /// 抽象通知者
 3     /// </summary>
 4   abstract class Subject
 5     {
 6         private IList<MyObserver> observers = new List<MyObserver>();
 7         //
 
新增抽象觀察者
 8         public void Attach(MyObserver myObserver)
 9         {
10             observers.Add(myObserver);
11         }
12         //移除抽象觀察者
13         public void Detach(MyObserver myObserver)
14         {
15             observers.Remove(myObserver);
16         }
17         //通知事件
18         public
 
 void Notify()
19         {
20             foreach (MyObserver observer in observers)
21             {
22                 observer.Update();
23             }
24         }
25     }
26     /// <summary>
27     /// 具體通知者
28     /// </summary>
29      class ConcreteSubject : Subject
30     {
31         //
 
通知者狀態
32         private string subjectState;
33 
34         public string SubjectState
35         {
36             get { return subjectState; }
37             set { subjectState = value; }
38         }
39     }
40     #endregion
41 
42     //抽象觀察者
43     abstract class MyObserver
44     {
45         //派生類會繼承並實現該方法
46         public abstract void Update();
47     }
48     //具體觀察者 需要訂閱通知者
49     class ConcreteObserver : MyObserver
50     {
51         private string Name;
52         private string observerstate;
53         private ConcreteSubject subject;
54 
55         public ConcreteObserver(string name, ConcreteSubject concretesubject)
56         {
57             Name = name;
58             subject = concretesubject;
59         }
60 
61         public override void Update()
62         {
63             observerstate = subject.SubjectState;
64             Console.WriteLine($"觀察者{Name}的新狀態是{observerstate}");
65         }
66     }

觀察者模式包括這4個部分抽象通知者，具體通知者，抽象觀察者，具體觀察者。提取抽象使其更加通用。

呼叫程式碼如下：

1 ConcreteSubject mysubject = new ConcreteSubject();
2 mysubject.Attach(new ConcreteObserver("張三", mysubject));
3 mysubject.Attach(new ConcreteObserver("李四", mysubject));
4 mysubject.SubjectState = "通知者開始傳送！";
5 mysubject.Notify();

結果如下：

優化：

在上述實現中，具體通知者還是需要顯式新增具體觀察者。是為了在通知時，呼叫各觀察者的Update方法。

但在實際情況中，各觀察者需要實現的方法都不相同。我們引入委託，定義一個EventHandler(事件處理程式)，動態地新增各觀察者的執行方法。

實現程式碼：

 1     interface ISubject
 2     {
 3         void Notify();
 4         string SubjcetState { get; set; }
 5     }
 6     //事件處理程式的委託
 7     delegate void EventHandler();

 8     class ConcreteSubjectTest : ISubject
 9     {
10         private string action;
11         public event EventHandler Update; 
12         public void Notify()
13         {
14             Update();
15         }
16         public string SubjcetState
17         {
18             get { return action; }
19             set { action = value; }
20         }
21     }
22 
23     class ConcreteObserverTest
24     {
25         private string name;
26         private ConcreteSubjectTest concreteSubjectTest;
27         public ConcreteObserverTest(string name, ConcreteSubjectTest concreteSubjectTest)
28         {
29             this.name = name;
30             this.concreteSubjectTest = concreteSubjectTest; 
31         }
32 
33         public void OffWork()
34         {
35             Console.WriteLine("下班啦");
36         }
37     }

呼叫程式碼：

1  ConcreteSubjectTest concreteSubjectTest = new ConcreteSubjectTest(); 
2  ConcreteObserverTest AA = new ConcreteObserverTest("王五", concreteSubjectTest);
3  concreteSubjectTest.Update += new Observer.EventHandler(AA.OffWork); 
4  concreteSubjectTest.Notify();

使用場景：事件匯流排的實現，在後面部落格會更新。主要還是圍繞高內聚，低耦合，提高可維護性

以上，僅用於學習和總結！