事件驱动架构Event Driven Architecture (EDA) 是一种低耦合可分布式的架构，它通常处理异步信息流。

通常可以把事件看作是业务领域中发生的一个变化。因此，在代码中我们需要定义事件，并且实例化该事件。在.net中，事件可以看作行为的结果。必然有事件发生者和接收者，触发事件的对象为发生者，响应事件的对象则为事件接收者。委托（delegate）则串联起发生者和接收者。C#中委托的概念不在此累述。下面代码是声明委托，初始化委托和调用委托的示例。

声明一个委托

1. public delegate int TestDelegate(object obj1, object obj2) ; 

实例化一个委托

1. TestDelegate TD = new TestDelegate(TestDelegateMethod) ; 

调用一个委托

1. TestDelegateMethod(" This is a Test."); 

注意，其实在C#中，更多的时候是使用event修饰的delegate。使用event修饰后的委托是一个特殊的委托，它的特殊性体现在对象的封装性上。比如上面的代码可以写成

event TestDelegate TD = TestDelegateMethod;关于event和delegate的更多细节可以参考博文

http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx

http://blog.monstuff.com/archives/000040.html

假设有如下一个应该场景，一个血压监测仪器，在病人每一次心跳的时候，监测血压，一旦发现病人血压小于80，则开始报警。

那么此处，动作的发出者就是病人，一旦发出心跳这个动作后，（通知）血压检测仪立即检测血压，如果小于80，则发出警报。

有一个BloodPressureMonitor类和Paient类。BloodPressureMonitor类只用一个方法，监测血压。病人类中主要有一个委托和一个HeartBeat()方法。其中每次调用HeartBeat()方法，都会调用委托方法。（此处，委托的意义类似于函数式编程的概念，将函数作为一个变量值，该变量赋予了哪个函数就调用哪个函数）。

因此，在main方法中，主要就是对dosth委托的赋值，也就是对病人每次心跳的时候，要调用一下血压检测仪的CheckPresssure方法。

代码如下：

   

1. public delegate void DoAction(int s); 
2.     class BloodPressureMonitor 
3.     { 
4.         public void CheckPresssure(int p) 
5.         { 
6.             if (p < 80) 
7.             { 
8.                 Console.WriteLine(String.Format("Alert!Bloodpressure is less than {0}", p)); 
9.             } 
10.             else 
11.             { 
12.                 Console.WriteLine(String.Format("Bloodpressure is {0}", p)); 
13.             } 
14.         } 
15.     } 
16.     class Patient { 
17.         public event DoAction dosth; 
18.         public String Name { get; set; } 
19.         public int BloodPressure { get; set; } 
20.         public void HeartBeat() 
21.         { 
22.             if (dosth != null) 
23.                 dosth(BloodPressure); 
24.         } 
25.     } 
26.     class Program 
27.     { 
28.         static void Main(string[] args) 
29.         { 
30.             Patient  p = new Patient(); 
31.             p.Name = "Tom"; 
32.             p.BloodPressure = 100; 
33.             BloodPressureMonitor monitor = new BloodPressureMonitor(); 
34.             p.dosth += monitor.CheckPresssure; 
35.             for (int i = 0; i < 10; i++) 
36.             { 
37.                 p.BloodPressure -= 5; 
38.                 p.HeartBeat(); 
39.             } 
40.         } 
41.     } 

运行结果如下：

也许很多人会觉得，那何必这么麻烦，直接在 HeartBeat方法中调用BloodPressureMonitor的CheckPresssure方法不就行了嘛，何必用委托呢？例如直接写成

1. public void HeartBeat() 
2.  { 
3.      new BloodPressureMonitor(). CheckPresssure( BloodPressure ); 
4.  } 

这样的写法不也是可以实现的吗？

是的，但是这种写法不灵活，首先，使用委托的话，可以利用委托的一些特点，比如调用委托的BeginInvoke方法可以异步在线程池线程上执行。

其次，如果此时再要加一个电话呼叫功能，一旦血压小于60，电话机自动呼叫医生，那么在现有的基础上，改起来十分容易。只需要加个电话类，然后在委托上再挂一个方法就行了。

代码如下:

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. namespace EDA 
6. { 
7.     public delegate void DoAction(int s);//定义一个委托 
8.     class BloodPressureMonitor 
9.     { 
10.         public void CheckPresssure(int p) 
11.         { 
12.             if (p < 80) 
13.             { 
14.                 Console.WriteLine(String.Format("Alert!Bloodpressure is less than {0}", p)); 
15.             } 
16.             else 
17.             { 
18.                 Console.WriteLine(String.Format("Bloodpressure is {0}", p)); 
19.             } 
20.         } 
21.     } 
22.     class Telephone 
23.     { 
24.         public void NeedCallDoctor(int p) 
25.         { 
26.             if (p < 60) 
27.             { 
28.                 Console.WriteLine(String.Format("Call doctor!", p)); 
29.             } 
30.         } 
31.     } 
32.     class Patient 
33.     { 
34.         public event DoAction dosth; 
35.         public String Name { get; set; } 
36.         public int BloodPressure { get; set; } 
37.         public void HeartBeat()//心跳时，调用dosth委托 
38.         { 
39.             if (dosth != null) 
40.                 dosth(BloodPressure); 
41.         } 
42.     } 
43.     class Program 
44.     { 
45.         static void Main(string[] args) 
46.         { 
47.             Patient p = new Patient(); 
48.             p.Name = "Tom"; 
49.             p.BloodPressure = 100; 
50.             BloodPressureMonitor monitor = new BloodPressureMonitor(); 
51.             p.dosth += monitor.CheckPresssure;//具体设定dosth是哪些方法。用+=可以挂载多个方法 
52.             Telephone Phone = new Telephone(); 
53.             p.dosth += Phone.NeedCallDoctor; 
54.             for (int i = 0; i < 10; i++) 
55.             { 
56.                 p.BloodPressure -= 5; 
57.                 p.HeartBeat(); 
58.             } 
59.         } 
60.     } 
61. }