一、委托的简介
1、委托的声明：
<access modifier> delegate <returnType> HandlerName ([parameters])
例如：
public delegate void PrintHandler(string str);
委托声明定义了一种类型，它用一组特定的参数以及返回类型来封装方法。对于静态方法，委托对象封装要调用的方法。对于实例方法，委托对象同时封装一个实例和该实例上的一个方法。如果您有一个委托对象和一组适当的参数，则可以用这些参数调用该委托。
2、委托的使用：
using System;
public class MyClass
{
public static void Main()
{
PrintStr myPrinter = new PrintStr();
PrintHandler myHandler = null;
myHandler += new PrintHandler(myPrinter.CallPrint); // 将委托链接到方法，来实例化委托
if(myHandler!=null)
myHandler("Hello World!"); // 调用委托，相当于匿名调用委托所链接的方法
Console.Read();
}
}
public delegate void PrintHandler(string str); // 声明委托类型
public class PrintStr
{
public void CallPrint(string input)
{
Console.WriteLine(input);
}
}
在C#中使用委托方法：
· 创建委托所使用的方法必须和委托声明相一致（参数列表、返回值都一致）
· 利用 +=、-=来进行委托的链接、取消链接或直接使用Delegate.Combine和Delegate.Remove方法来实现
· 可以使用MulticastDelegate的实例方法GetInvocationList()来获取委托链中所有的委托
· 不能撰写包含 out 参数的委托
二、事件的简介
C# 中的“事件”是当对象发生某些事情时，类向该类的客户提供通知的一种方法。
1、事件的声明：
声明的格式为：<access modifier> event <delegate type> EventName
因为使用委托来声明事件，所以在类里声明事件时，首先必须先声明该事件的委托类型<delegate type>（如果尚未声明的话）。在上面我们已经提到过了委托类型的声明，但是在.net framework下为事件使用的委托类型进行声明时有更严格的规定：
（1）、 事件的委托类型应采用两个参数；
（2）、两个参数分别是：指示事件源的“对象源”参数和封装事件的其他任何相关信息的“e”参数；
（3）、“e”参数的类型应为EventArgs 类或派生自 EventArgs 类。
如下的定义：
public delegate void PrintHandler(object sender,System.EventArgs e);
然后我们才能声明该委托类型的事件
例如：
public event PrintHandler Print;
当事件发生时，将调用其客户提供给它的委托。
2、调用事件：
类声明了事件以后，可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件绑定，则该字段将为空；否则该字段引用应在调用该事件时调用的委托。因此，调用事件时通常先检查是否为空，然后再调用事件。（调用事件，即触发事件，只能从声明该事件的类内进行）
if(Print != null)
{
Print (this,e);
}
3、事件绑定：
从类的外面来看，事件就象类的一个公共成员，通过 类名.事件名 的形式来访问，但是只能对它做绑定和解除绑定的操作，而不能有其他操作。
类名. Print += new PrintHandler(绑定的方法名) // 将某个方法绑定到Print事件上
类名. Print -= new PrintHandler(绑定的方法名) // 将某个已绑定到Print事件上的方法从Print事件上解除
三、委托和事件的使用
委托和事件在用户界面程序里用的比较的多，比如象在winform或webform的用户UI上的button和它的click事件：
// 将Button1_Click()方法绑定到按钮控件Button1的Click事件上
this.Button1.Click += new System.EventHandler(this. Button1_Click);
private void Button1_Click(object sender, System.EventArgs e) // Button1_Click()方法
{
……
}
然而除了用户界面程序外，在很多其他地方也用到了事件驱动模式，比如观察者模式（Observer）或发布/订阅（Publish/Subscribe）里：在一个类里发布（Publish）某个可以被触发的事件，而其他的类就可以来订阅（Subscribe）该事件。一旦这个发布者类触发了该事件，那么运行时环境会立刻告知所有订阅了该事件的订阅者类：这个事件发生了！从而各个订阅者类可以作出它们自己的反应（调用相应方法）。
我们来举一个生活中的实际例子来说明如何使用委托和事件，以及使用委托和事件所带来的好处：
比如说有一个公司（场景），你是老板，手下有主管和员工，作为老板你会指派（委托）主管管理员工的工作，如果某个员工玩游戏，则让某个主管从该员工的薪水里扣去500元钱。
这就是现实中的委托。
而在写程序中，假设程序员就是老板，有两个类分别为主管和员工，而主管小王和员工小张就是两个类的对象实例。员工类有一个方法：玩游戏，同时就有一个玩游戏的事件，他一玩游戏就会激发这个事件。而主管类就是负责处理该事件的，他负责把玩游戏的员工的薪水扣除500。
（一）、首先，我们来看看在非委托的情况下比较常见的一种设计方式（当然这不是唯一的方式，也不是最好的方式，但是很常见）：
using System;
namespace CSharpConsole
{
public class 场景
{
[STAThread]
public static void Main(string[] args)
{
Console.WriteLine("场景开始了.");
// 生成主管类的对象实例 小王
主管 小王 = new 主管();
// 生成员工类的对象实例 小张，指定他的主管
员工 小张 = new 员工(小王);
Console.WriteLine("该员工本有的薪水：" + 小张.薪水.ToString());
// 员工开始玩游戏
小张.玩游戏();
Console.WriteLine("现在该员工还剩下：" +小张.薪水.ToString());
Console.WriteLine("场景结束");
Console.ReadLine();
}
}
// 负责扣钱的人----主管
public class 主管
{
public 主管()
{
Console.WriteLine("生成主管");
}
public void 扣薪水(员工 employee)
{
Console.WriteLine("主管：好小子，上班时间胆敢玩游戏");
Console.WriteLine("主管：看看你小子有多少薪水");
Console.WriteLine("开始扣薪水...");
System.Threading.Thread.Sleep(1000);
employee.薪水 = employee.薪水 - 500;
Console.WriteLine("扣薪水执行完毕.");
}
}
// 如果玩游戏，则会引发事件
public class 员工
{
// 保存员工的薪水
private int m_Money;
// 保存该员工的主管
private 主管 m_Manager;
public 员工(主管 manager)
{
Console.WriteLine("生成员工.");
m_Manager = manager; // 通过构造函数，初始化员工的主管。
m_Money = 1000; // 通过构造函数，初始化员工的薪水。
}
public int 薪水 // 此属性可以操作员工的薪水 。
{
get
{
return m_Money;
}
set
{
m_Money = value;
}
}
public void 玩游戏()
{
Console.WriteLine("员工开始玩游戏了..");
Console.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");
System.Threading.Thread.Sleep(1000);
m_Manager. 扣薪水(this);
}
}
}
这种方法所带来的问题： 员工类和主管类的耦合性太高
1、 在客户程序里必须先创建了主管类之后才能生成员工类，如果在不需要主管类对象而只需员工类对象的地方，为了创建所需的员工类对象实例，你也不得不去先创建一个主管类的对象实例；
2、 如果场景剧本（即客户程序需求）发生了变化
（1）、现在要让一个新的角色（一个新的类），如保安，来代替主管，负责在员工玩游戏时扣员工薪水，那么我们不得不去修改员工类，或许还需要修改主管类；
（2）、如果场景剧本增加新的需求，要求员工在玩游戏后，不但要扣薪水，还要在绩效上扣分，那么我们也不得不修改员工类。
（二）、利用委托的实现：
下面有个例子：在C# 控制台应用程序编辑运行成功：
using System;
namespace CSharpConsole
{
// 定义委托
public delegate void PlayGameHandler(object sender,System.EventArgs e);
// 负责扣钱的人----主管
public class 主管
{
public 主管()
{
Console.WriteLine("生成主管");
}
public void 扣薪水(object sender,EventArgs e)
{
Console.WriteLine("主管：好小子，上班时间胆敢玩游戏");
Console.WriteLine("主管：看看你小子有多少薪水");
员工 employee = (员工)sender;
Console.WriteLine("开始扣薪水...");
System.Threading.Thread.Sleep(1000);
employee.薪水 = employee.薪水 - 500;
Console.WriteLine("扣薪水执行完毕.");
}
}
// 如果玩游戏，则会引发事件
public class 员工
{
// 先定义一个事件，这个事件表示员工在玩游戏。
public event PlayGameHandler PlayGame;
// 保存员工薪水的变量
private int m_Money;
public 员工()
{
Console.WriteLine("生成员工.");
m_Money = 1000; // 构造函数，初始化员工的薪水。
}
public int 薪水 // 此属性可以操作员工的薪水 。
{
get
{
return m_Money;
}
set
{
m_Money = value;
}
}
public void 玩游戏()
{
Console.WriteLine("员工开始玩游戏了..");
Console.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");
System.Threading.Thread.Sleep(1000);
System.EventArgs e = new EventArgs();
OnPlayGame(e);
}
protected virtual void OnPlayGame(EventArgs e)
{
if(PlayGame != null)
{
PlayGame(this,e);
}
}
}
public class 场景
{
[STAThread]
public static void Main(string[] args)
{
Console.WriteLine("场景开始了.");
// 生成主管类的对象实例 小王
主管 小王 = new 主管();
// 生成员工类的对象实例 小张
员工 小张 = new 员工();
// 设下委托，指定监视
小张.PlayGame += new PlayGameHandler(小王. 扣薪水);
Console.WriteLine("该员工本有的薪水：" + 小张.薪水.ToString());
// 员工开始玩游戏
小张.玩游戏();
Console.WriteLine("现在该员工还剩下：" +小张.薪水.ToString());
Console.WriteLine("场景结束");
Console.ReadLine();
}
}
}
对于前面提出的问题：
1、 解耦了主管类和员工类之间的必然联系，可以单独创建员工类对象实例，而不用管是否有主管类对象实例的存在；
2、 在客户程序需求变化时：
（1）、我们只需修改客户程序，即上面例子里的class 场景，将委托改为如下：
保安 小李 = new 保安();
小张.PlayGame += new PlayGameHandler(小李. 扣薪水);
即可实现由保安来负责扣薪水的需求变化，而不用动员工类。
（2）、我们只需修改客户程序，即上面例子里的class 场景，添加一个如下的委托：
小张.PlayGame += new PlayGameHandler(某某. 扣绩效分);
这个“某某”可以是主管，也可以是其他新的角色（新的类），只需要在“某某”对应的类里定义扣绩效分的动作即可，而不用动员工类。
四、总结：
当然，不使用委托和事件我们仍然可以设计出解耦的类，然而却会增加很多的类、接口以及关联等等，增加了代码量和程序的逻辑复杂性，而在.net里利用委托和事件我们只需少的多的代码来实现。
委托和事件的使用有如下几个要素：
1、激发事件的对象-----就是员工小张
2、处理对象事件的对象-----就是主管小王
3、定义委托，就是你让主管小王监视员工小张。
如果这三个要素都满足的话，则你就写出了一个完整事件的处理。
1、委托的声明：
<access modifier> delegate <returnType> HandlerName ([parameters])
例如：
public delegate void PrintHandler(string str);
委托声明定义了一种类型，它用一组特定的参数以及返回类型来封装方法。对于静态方法，委托对象封装要调用的方法。对于实例方法，委托对象同时封装一个实例和该实例上的一个方法。如果您有一个委托对象和一组适当的参数，则可以用这些参数调用该委托。
2、委托的使用：
using System;
public class MyClass
{
public static void Main()
{
PrintStr myPrinter = new PrintStr();
PrintHandler myHandler = null;
myHandler += new PrintHandler(myPrinter.CallPrint); // 将委托链接到方法，来实例化委托
if(myHandler!=null)
myHandler("Hello World!"); // 调用委托，相当于匿名调用委托所链接的方法
Console.Read();
}
}
public delegate void PrintHandler(string str); // 声明委托类型
public class PrintStr
{
public void CallPrint(string input)
{
Console.WriteLine(input);
}
}
在C#中使用委托方法：
· 创建委托所使用的方法必须和委托声明相一致（参数列表、返回值都一致）
· 利用 +=、-=来进行委托的链接、取消链接或直接使用Delegate.Combine和Delegate.Remove方法来实现
· 可以使用MulticastDelegate的实例方法GetInvocationList()来获取委托链中所有的委托
· 不能撰写包含 out 参数的委托
二、事件的简介
C# 中的“事件”是当对象发生某些事情时，类向该类的客户提供通知的一种方法。
1、事件的声明：
声明的格式为：<access modifier> event <delegate type> EventName
因为使用委托来声明事件，所以在类里声明事件时，首先必须先声明该事件的委托类型<delegate type>（如果尚未声明的话）。在上面我们已经提到过了委托类型的声明，但是在.net framework下为事件使用的委托类型进行声明时有更严格的规定：
（1）、 事件的委托类型应采用两个参数；
（2）、两个参数分别是：指示事件源的“对象源”参数和封装事件的其他任何相关信息的“e”参数；
（3）、“e”参数的类型应为EventArgs 类或派生自 EventArgs 类。
如下的定义：
public delegate void PrintHandler(object sender,System.EventArgs e);
然后我们才能声明该委托类型的事件
例如：
public event PrintHandler Print;
当事件发生时，将调用其客户提供给它的委托。
2、调用事件：
类声明了事件以后，可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件绑定，则该字段将为空；否则该字段引用应在调用该事件时调用的委托。因此，调用事件时通常先检查是否为空，然后再调用事件。（调用事件，即触发事件，只能从声明该事件的类内进行）
if(Print != null)
{
Print (this,e);
}
3、事件绑定：
从类的外面来看，事件就象类的一个公共成员，通过 类名.事件名 的形式来访问，但是只能对它做绑定和解除绑定的操作，而不能有其他操作。
类名. Print += new PrintHandler(绑定的方法名) // 将某个方法绑定到Print事件上
类名. Print -= new PrintHandler(绑定的方法名) // 将某个已绑定到Print事件上的方法从Print事件上解除
三、委托和事件的使用
委托和事件在用户界面程序里用的比较的多，比如象在winform或webform的用户UI上的button和它的click事件：
// 将Button1_Click()方法绑定到按钮控件Button1的Click事件上
this.Button1.Click += new System.EventHandler(this. Button1_Click);
private void Button1_Click(object sender, System.EventArgs e) // Button1_Click()方法
{
……
}
然而除了用户界面程序外，在很多其他地方也用到了事件驱动模式，比如观察者模式（Observer）或发布/订阅（Publish/Subscribe）里：在一个类里发布（Publish）某个可以被触发的事件，而其他的类就可以来订阅（Subscribe）该事件。一旦这个发布者类触发了该事件，那么运行时环境会立刻告知所有订阅了该事件的订阅者类：这个事件发生了！从而各个订阅者类可以作出它们自己的反应（调用相应方法）。
我们来举一个生活中的实际例子来说明如何使用委托和事件，以及使用委托和事件所带来的好处：
比如说有一个公司（场景），你是老板，手下有主管和员工，作为老板你会指派（委托）主管管理员工的工作，如果某个员工玩游戏，则让某个主管从该员工的薪水里扣去500元钱。
这就是现实中的委托。
而在写程序中，假设程序员就是老板，有两个类分别为主管和员工，而主管小王和员工小张就是两个类的对象实例。员工类有一个方法：玩游戏，同时就有一个玩游戏的事件，他一玩游戏就会激发这个事件。而主管类就是负责处理该事件的，他负责把玩游戏的员工的薪水扣除500。
（一）、首先，我们来看看在非委托的情况下比较常见的一种设计方式（当然这不是唯一的方式，也不是最好的方式，但是很常见）：
using System;
namespace CSharpConsole
{
public class 场景
{
[STAThread]
public static void Main(string[] args)
{
Console.WriteLine("场景开始了.");
// 生成主管类的对象实例 小王
主管 小王 = new 主管();
// 生成员工类的对象实例 小张，指定他的主管
员工 小张 = new 员工(小王);
Console.WriteLine("该员工本有的薪水：" + 小张.薪水.ToString());
// 员工开始玩游戏
小张.玩游戏();
Console.WriteLine("现在该员工还剩下：" +小张.薪水.ToString());
Console.WriteLine("场景结束");
Console.ReadLine();
}
}
// 负责扣钱的人----主管
public class 主管
{
public 主管()
{
Console.WriteLine("生成主管");
}
public void 扣薪水(员工 employee)
{
Console.WriteLine("主管：好小子，上班时间胆敢玩游戏");
Console.WriteLine("主管：看看你小子有多少薪水");
Console.WriteLine("开始扣薪水...");
System.Threading.Thread.Sleep(1000);
employee.薪水 = employee.薪水 - 500;
Console.WriteLine("扣薪水执行完毕.");
}
}
// 如果玩游戏，则会引发事件
public class 员工
{
// 保存员工的薪水
private int m_Money;
// 保存该员工的主管
private 主管 m_Manager;
public 员工(主管 manager)
{
Console.WriteLine("生成员工.");
m_Manager = manager; // 通过构造函数，初始化员工的主管。
m_Money = 1000; // 通过构造函数，初始化员工的薪水。
}
public int 薪水 // 此属性可以操作员工的薪水 。
{
get
{
return m_Money;
}
set
{
m_Money = value;
}
}
public void 玩游戏()
{
Console.WriteLine("员工开始玩游戏了..");
Console.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");
System.Threading.Thread.Sleep(1000);
m_Manager. 扣薪水(this);
}
}
}
这种方法所带来的问题： 员工类和主管类的耦合性太高
1、 在客户程序里必须先创建了主管类之后才能生成员工类，如果在不需要主管类对象而只需员工类对象的地方，为了创建所需的员工类对象实例，你也不得不去先创建一个主管类的对象实例；
2、 如果场景剧本（即客户程序需求）发生了变化
（1）、现在要让一个新的角色（一个新的类），如保安，来代替主管，负责在员工玩游戏时扣员工薪水，那么我们不得不去修改员工类，或许还需要修改主管类；
（2）、如果场景剧本增加新的需求，要求员工在玩游戏后，不但要扣薪水，还要在绩效上扣分，那么我们也不得不修改员工类。
（二）、利用委托的实现：
下面有个例子：在C# 控制台应用程序编辑运行成功：
using System;
namespace CSharpConsole
{
// 定义委托
public delegate void PlayGameHandler(object sender,System.EventArgs e);
// 负责扣钱的人----主管
public class 主管
{
public 主管()
{
Console.WriteLine("生成主管");
}
public void 扣薪水(object sender,EventArgs e)
{
Console.WriteLine("主管：好小子，上班时间胆敢玩游戏");
Console.WriteLine("主管：看看你小子有多少薪水");
员工 employee = (员工)sender;
Console.WriteLine("开始扣薪水...");
System.Threading.Thread.Sleep(1000);
employee.薪水 = employee.薪水 - 500;
Console.WriteLine("扣薪水执行完毕.");
}
}
// 如果玩游戏，则会引发事件
public class 员工
{
// 先定义一个事件，这个事件表示员工在玩游戏。
public event PlayGameHandler PlayGame;
// 保存员工薪水的变量
private int m_Money;
public 员工()
{
Console.WriteLine("生成员工.");
m_Money = 1000; // 构造函数，初始化员工的薪水。
}
public int 薪水 // 此属性可以操作员工的薪水 。
{
get
{
return m_Money;
}
set
{
m_Money = value;
}
}
public void 玩游戏()
{
Console.WriteLine("员工开始玩游戏了..");
Console.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");
System.Threading.Thread.Sleep(1000);
System.EventArgs e = new EventArgs();
OnPlayGame(e);
}
protected virtual void OnPlayGame(EventArgs e)
{
if(PlayGame != null)
{
PlayGame(this,e);
}
}
}
public class 场景
{
[STAThread]
public static void Main(string[] args)
{
Console.WriteLine("场景开始了.");
// 生成主管类的对象实例 小王
主管 小王 = new 主管();
// 生成员工类的对象实例 小张
员工 小张 = new 员工();
// 设下委托，指定监视
小张.PlayGame += new PlayGameHandler(小王. 扣薪水);
Console.WriteLine("该员工本有的薪水：" + 小张.薪水.ToString());
// 员工开始玩游戏
小张.玩游戏();
Console.WriteLine("现在该员工还剩下：" +小张.薪水.ToString());
Console.WriteLine("场景结束");
Console.ReadLine();
}
}
}
对于前面提出的问题：
1、 解耦了主管类和员工类之间的必然联系，可以单独创建员工类对象实例，而不用管是否有主管类对象实例的存在；
2、 在客户程序需求变化时：
（1）、我们只需修改客户程序，即上面例子里的class 场景，将委托改为如下：
保安 小李 = new 保安();
小张.PlayGame += new PlayGameHandler(小李. 扣薪水);
即可实现由保安来负责扣薪水的需求变化，而不用动员工类。
（2）、我们只需修改客户程序，即上面例子里的class 场景，添加一个如下的委托：
小张.PlayGame += new PlayGameHandler(某某. 扣绩效分);
这个“某某”可以是主管，也可以是其他新的角色（新的类），只需要在“某某”对应的类里定义扣绩效分的动作即可，而不用动员工类。
四、总结：
当然，不使用委托和事件我们仍然可以设计出解耦的类，然而却会增加很多的类、接口以及关联等等，增加了代码量和程序的逻辑复杂性，而在.net里利用委托和事件我们只需少的多的代码来实现。
委托和事件的使用有如下几个要素：
1、激发事件的对象-----就是员工小张
2、处理对象事件的对象-----就是主管小王
3、定义委托，就是你让主管小王监视员工小张。
如果这三个要素都满足的话，则你就写出了一个完整事件的处理。
