https://www.cnblogs.com/yinqixin/p/5056307.html
每一個初學C#的程序猿，在剛剛碰到委托和事件的概念時，估計都是望而卻步，茫然摸不到頭腦的。百度一搜，關於概念介紹的文章大把大把的，當然也不乏深入淺出的好文章。可看完這些文章，大多數新手，估計也只是信心滿滿的覺得自己看懂了，一旦要在自己的程序中用上委托和事件，就傻眼了，根本不知道什么情況下該用，也不知道具體怎么用。
本文沒有任何概念介紹，旨在幫助同學們快速用上委托和事件，進入C#的更高境界。
- 首先，我們需要知道，到底在什么情況下必須使用委托和事件呢？
請看下面的場景：首領A要搞一場鴻門宴，吩咐部下B和C各自帶隊埋伏在屏風兩側，約定以杯為令：若左手舉杯，則B帶隊殺出；若右手舉杯，則C帶隊殺出；若直接摔杯，則B和C同時殺出。B和C襲擊的具體方法，首領A並不關心。(完整代碼在全文最后。)
有腦子反應快的同學，馬上說，這個邏輯，用一個IF條件判斷語句不就搞定了嗎：
1 if(左手舉杯)
2 {
3 B帶隊殺出;
4 }
5 else if(右手舉杯)
6 {
7 C帶隊殺出;
8 }
9 else if(直接摔杯)
10 {
11 B帶隊殺出;
12 C帶隊殺出;
13 }
14 else
15 {
16 按兵不動
17 }
如果真這么簡單，那我還寫這篇文章干嘛呢。請這位同學認真想想：首領A會什么時候發出信號呢？估計連他自己都不知道。那么上面這段偽碼，你打算插入到哪里呢？難道B和C就一直不停的用While循環做上述判斷嗎？顯然不合適吧。更重要的，如果擴展一下，部下不止B和C，而是B、C、D、E等等，每個人都有自己不同的響應領導號召的方法，那么對首領A而言，要分別去跟每個部下打交道，上述的偽碼，會進行無盡的擴展和完善，顯然也不是我們所希望的。
正確的邏輯應該是，B和C不管宴席上發生的任何其他事情，只等首領發出舉杯或者摔杯的信號，一旦首領A發出信號，相當於通知了所有部下，凡是約定好的部下，都立馬各自行動！
我們定義三個類，分別模擬首領A和部下B、C：
/// <summary>
/// 首領A
/// </summary>
public class A
{
}
/// <summary>
/// 部下B
/// </summary>
public class B
{
}
/// <summary>
/// 部下C
/// </summary>
public class C
{
}
首領A的類有舉杯和摔杯兩種方法，其中，舉杯方法帶有一個形參，用於傳遞是左手舉杯，還是右手舉杯。部下B和C的類，各自有一種攻擊方法。
/// <summary>
/// 首領A
/// </summary>
public class A
{
/// <summary>
/// 舉杯
/// </summary>
/// <param name="hand">手：左、右</param>
public void Raise(string hand)
{
Console.WriteLine("首領A{0}手舉杯", hand);
}
/// <summary>
/// 摔杯
/// </summary>
public void Fall()
{
Console.WriteLine("首領A摔杯");
}
}
/// <summary>
/// 部下B
/// </summary>
public class B
{
/// <summary>
/// 攻擊
/// </summary>
public void Attack()
{
Console.WriteLine("部下B發起攻擊");
}
}
/// <summary>
/// 部下C
/// </summary>
public class C
{
/// <summary>
/// 攻擊
/// </summary>
public void Attack()
{
Console.WriteLine("部下C發起攻擊");
}
}
至此，三個獨立的類，構造完畢。那么，怎么讓部下B和C，根據首領的暗語才去相應的行動呢？
我們需要在首領A類中，采用一種方法，把其意圖傳遞出去。在首領A類之前，分別定義一個帶形參的舉杯委托RaiseEventHandler和一個不帶形參的摔杯委托FallEventHandler。命名規則是在准備傳遞的方法名后加上EventHandler，不要問我為什么，介紹為什么的文章多得是，大家大可以去查閱。本文的宗旨是，教會大家如何快速的使用委托和事件。當然，你也可以不遵循此命名規則，對程序的運行沒有任何影響，只是會增加自己或他人日后閱讀代碼的難度。
delegate void RaiseEventHandler(string hand); delegate void FallEventHandler();
然后，在首領A類中，定義兩個事件。這個類似於大家在WinForm中拖放一個Button后，雙擊該Button，即可編輯其事件。
/// <summary>
/// 首領A舉杯事件
/// </summary>
public event RaiseEventHandler RaiseEvent;
/// <summary>
/// 首領A摔杯事件
/// </summary>
public event FallEventHandler FallEvent;
好了，做完上面兩個步驟后，就可以在首領A的舉杯和摔杯方法中，調用上述兩個事件了。這樣，如果B和C中訂閱該事件，便可自動執行了。
/// <summary>
/// 舉杯
/// </summary>
/// <param name="hand">手：左、右</param>
public void Raise(string hand)
{
Console.WriteLine("首領A{0}手舉杯", hand);
// 調用舉杯事件，傳入左或右手作為參數
if (RaiseEvent!=null)
{
RaiseEvent(hand);
}
}
/// <summary>
/// 摔杯
/// </summary>
public void Fall()
{
Console.WriteLine("首領A摔杯");
// 調用摔杯事件
if (FallEvent!=null)
{
FallEvent();
}
}
同樣，不要問為什么這樣寫。按照上述操作即可。一旦用熟這種方法，體會其中含義，自然就明白為何這么寫了。
在部下B和C心中，必須存在首領A，才能執行A的暗示吧。所以，在B類和C類中，需要聲明一個A，該聲明可以通過B和C的構造函數進行實例化。實例化之后，便可在類B和類C中訂閱類A的事件了。
完整代碼如下：
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 A a = new A(); // 定義首領A
6
7 B b = new B(a); // 定義部下B
8
9 C c = new C(a); // 定義部下C
10
11 // 首領A左手舉杯
12 a.Raise("左");
13
14 // 首領A右手舉杯
15 //a.Raise("右");
16
17 // 首領A摔杯
18 //a.Fall();
19
20 Console.ReadLine();
21 // 由於B和C訂閱了A的事件，所以無需任何代碼，B和C均會按照約定進行動作。
22 }
23 }
24
25 /// <summary>
26 /// 首領A舉杯委托
27 /// </summary>
28 /// <param name="hand">手：左、右</param>
29 public delegate void RaiseEventHandler(string hand);
30 /// <summary>
31 /// 首領A摔杯委托
32 /// </summary>
33 public delegate void FallEventHandler();
34 /// <summary>
35 /// 首領A
36 /// </summary>
37 public class A
38 {
39 /// <summary>
40 /// 首領A舉杯事件
41 /// </summary>
42 public event RaiseEventHandler RaiseEvent;
43 /// <summary>
44 /// 首領A摔杯事件
45 /// </summary>
46 public event FallEventHandler FallEvent;
47
48 /// <summary>
49 /// 舉杯
50 /// </summary>
51 /// <param name="hand">手：左、右</param>
52 public void Raise(string hand)
53 {
54 Console.WriteLine("首領A{0}手舉杯", hand);
55 // 調用舉杯事件，傳入左或右手作為參數
56 if (RaiseEvent!=null)
57 {
58 RaiseEvent(hand);
59 }
60 }
61 /// <summary>
62 /// 摔杯
63 /// </summary>
64 public void Fall()
65 {
66 Console.WriteLine("首領A摔杯");
67 // 調用摔杯事件
68 if (FallEvent!=null)
69 {
70 FallEvent();
71 }
72 }
73 }
74 /// <summary>
75 /// 部下B
76 /// </summary>
77 public class B
78 {
79 A a;
80
81 public B(A a)
82 {
83 this.a = a;
84 a.RaiseEvent += new RaiseEventHandler(a_RaiseEvent); // 訂閱舉杯事件
85 a.FallEvent += new FallEventHandler(a_FallEvent); // 訂閱摔杯事件
86 }
87 /// <summary>
88 /// 首領舉杯時的動作
89 /// </summary>
90 /// <param name="hand">若首領A左手舉杯，則B攻擊</param>
91 void a_RaiseEvent(string hand)
92 {
93 if (hand.Equals("左"))
94 {
95 Attack();
96 }
97 }
98
99 /// <summary>
100 /// 首領摔杯時的動作
101 /// </summary>
102 void a_FallEvent()
103 {
104 Attack();
105 }
106
107 /// <summary>
108 /// 攻擊
109 /// </summary>
110 public void Attack()
111 {
112 Console.WriteLine("部下B發起攻擊，大喊：猛人張飛來也！");
113 }
114 }
115 /// <summary>
116 /// 部下C
117 /// </summary>
118 public class C
119 {
120 A a;
121 public C(A a)
122 {
123 this.a = a;
124 a.RaiseEvent += new RaiseEventHandler(a_RaiseEvent); // 訂閱舉杯事件
125 a.FallEvent += new FallEventHandler(a_FallEvent); // 訂閱摔杯事件
126 }
127 /// <summary>
128 /// 首領舉杯時的動作
129 /// </summary>
130 /// <param name="hand">若首領A右手舉杯，則攻擊</param>
131 void a_RaiseEvent(string hand)
132 {
133 if (hand.Equals("右"))
134 {
135 Attack();
136 }
137 }
138
139 /// <summary>
140 /// 首領摔杯時的動作
141 /// </summary>
142 void a_FallEvent()
143 {
144 Attack();
145 }
146 /// <summary>
147 /// 攻擊
148 /// </summary>
149 public void Attack()
150 {
151 Console.WriteLine("部下C發起攻擊，一套落英神掌打得虎虎生威~");
152 }
153 }
--==
我的理解如下：
委托就是對一個方法映射，把方法名當參數來傳遞，類似JS中的在某個function的參數中把另一個function的名稱當參數來傳遞。
//定義委托原型
delegate void UpdateHandler(int id);
//定義符合委托原型的方法UpdateMember
void UpdateMember(int id)
{
//更新用戶邏輯
}
//定義符合委托原型的方法DeleteMember
void DeleteMember(int id)
{
//刪除用戶邏輯
}
如何使用呢，如下：
//實例化委托對象，再構造函數中把方法名當參數來傳遞。
UpdateHandler handler = new UpdateHandler(UpdateMember);
//執行委托對象
handler(某個用戶id);
handler(某個用戶id)就等價於
UpdateMember(某個用戶id)
也可以連接多個相同簽名的方法，組成一個委托鏈，當調用委托對象時，鏈上的方法，按映射的順序一次被執行。
如何使用呢，如下：
UpdateHandler handler = new UpdateHandler(UpdateMember);
handler += DeleteMember;
handler(某個用戶id);
handler(某個用戶id)就等價於
UpdateMember(某個用戶id)
DeleteMember(某個用戶id)
事件的話，看看設計模式中的觀察者模式。
被觀察對象中維護了一個觀察者列表，這些觀察者會對被觀察者某個“動作”，即事件，做出各自不同的反映。
常見的例子如下：
某一場景下有主人，貓，狗3個對象。
當主人“打開門”后，貓“跑開了”，狗“叫了”。
整個過程中，主人就是被觀察對象，貓和狗都是觀察者。
一旦主人觸發“打開門”這個事件的話，貓狗做出不同的反映，貓“跑開了”，狗“叫了”。
代碼如下：
public class Host
{
//定義委托原型
public delegate void OpenDoorEventHandler();
//定義委托類型的事件
public event GoHomeEventHandler OpenDoor;
//定義內部一個方法，在這個方法內判斷，OpenDoor事件是否被其他對象注冊，一旦注冊了，則調用執行事件。
protected void OnOpenDoor()
{
if(OpenDoor!=null)
{
OpenDoor();
}
}
public void GoHome()
{
OnOpenDoor();
}
}
public class Cat
{
public void Run()
{
//貓跑了
}
}
public class Dog
{
public void Bark()
{
//狗叫了
}
}
如何使用如下：
Host 主人 =new Host();
Cat 貓 = new Cat();
Dog 狗 = new Dog();
主人.OpenDoor += new 主人.OpenDoorEventHandler(貓.Run);
主人.OpenDoor += new 主人.OpenDoorEventHandler(狗.Back);
主人.GoHome就等價於
貓.Run();
狗.Back();
當被觀察者，做出某一特定“動作”(被觀察者的特定“動作”，注冊了N個不同對象的不同反映)，觀察者對這個特定“動作”做出不懂的反映。
--==
C# delegate方法invoke和beginInvoke的區別
class Program
{
delegate void test();
static void Main(string[] args)
{
test ts = new test(TestDelegate);
ts.BeginInvoke(null,null); //使用到委托的beginInvoke方法
Console.WriteLine("hello");
}
internal static void TestDelegate()
{
Thread.Sleep(5000);
}
}
上面程序代碼中使用到begininvoke方法，此時控制台會立刻輸出hello字符，然后結束主程序運行。由此可知beginInvoke是在主線程之外，另起了一個線程來運行其所需的代碼。
再看下面這點程序
class Program
{
delegate void test();
static void Main(string[] args)
{
test ts = new test(TestDelegate);
ts.Invoke(); //使用到委托的invoke方法
Console.WriteLine("hello");
}
internal static void TestDelegate()
{
Thread.Sleep(5000);
}
}
唯一區別就是使用到了 invoke方法，此時控制台會等待5秒，然后才輸出hello字符。由此可知invoke是使用主線程運行其代碼的，並沒有另起線程。