委托
委托是什么
委托本质就是函数的地址，类似c++中的函数指针。
使用委托，可以实现把函数作为参数，在另一个函数中调用。
使用委托可以将函数引用封装在委托对象内。然后调用该委托对象就可以执行委托对象内函数引用指向的函数，而不必在编译时知道将调用哪个函数。
多播委托（委托链）：通过+=不断的进行注册方法，实现一次性调用多个方法。
好处是：
- 可以在不修改调用方法的前提下，不断的增加业务功能。大大减少程序中逻辑判断的分支
- 实现“调用方”与“实现方”的解耦合
委托怎么用
- 定义委托，使用delegate关键字
- 声明委托实例
- 委托方法注册
- 委托的函数签名必须与将要绑定的方法的签名一致
- +=添加注册；-=取消注册；直接用= 仅最后注册的方法有效
- 调用委托
- 直接调用
class UseDelegate
{
//2.声明委托
InformInfoHandler myInform;
public UseDelegate()
{
//3.委托注册
myInform = new InformInfoHandler(InformA);
myInform += new InformInfoHandler(InformB);
}
public void SendInfo()
{
//4.调用委托（直接调用）
myInform("I am cx");
}
private void InformA(string name)
{
Console.WriteLine("{0},Hello A", name);
}
private void InformB(string name)
{
Console.WriteLine("{0},Hello B", name);
}
}委托的底层原理
委托本质上就是一个“类”，能定义类的地方，都可以定义委托。
（可通过反编译软件，进行查看证明，委托就是继承了[mscorlib]System.MulticastDelegate的特殊类）
三个核心方法：BeginInvoke,EndInvoke和Invoke
封送一个委托方法，类似于使用PostMessage进行通信，异步操作，使用EndInvoke方法等待异步操作的完成。
就是一个能存放很多函数指针的调用列表（但函数签名必须和委托类型签名一样)，你一调用这个列表，那么列表里的所有的指针所对应的方法依次被执行。
委托对象 obj 在创建时创建了指向方法 SayHi的指针并保存在 _methodPtr中；_target中保存了SayHi方法所在的类的对象(比如我把这段代码写在窗体里按钮的点击方法中，那么此时 _target就是 SayHi方法所在的窗体对象)；_invocationList 中保存了追加的两个方法的指针。
委托 vs 函数指针
函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。
在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。
其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。
为什么委托定义的返回值通常都为void？
- 委托变量可以供多个订阅者注册，如果定义了返回值，那么多个订阅者的方法都会向发布者返回数值，结果就是后面一个返回的方法值将前面的返回值覆盖掉了，因此，实际上只能获得最后一个方法调用的返回值。
- 发布者和订阅者是松耦合的，发布者根本不关心谁订阅了它的事件、为什么要订阅，更别说订阅者的返回值了，所以返回订阅者的方法返回值大多数情况下根本没有必要。
事件
事件是什么
事件是基于特定类的，用于事件驱动模型的专用委托。
事件本质是对委托的封装，对外提供add_EventName(对应+=)和remove_EventName(对应-=)访问
可以将公有的委托变量定义为私有变量，从而满足类的封装性原则
Event就是封装了委托类型的变量，使得：在类的内部，不管你声明它是public还是protected，它总是private的。在类的外部，注册“+=”和注销“-=”的访问限定符与你在声明事件时使用的访问符相同。
C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
事件怎么用
声明一个事件
public event InformInfoHandler eveMyInform;
委托 vs 事件(推荐)：
事件本质上是委托的一个实例
委托可以定义在类的外部，事件只能定义在类的内部，封装性。
委托你不但可以安排谁是它的调用函数,还可以直接调用它,而事件不能直接调用,只能通过某些操作触发。事件仅仅是供其他类型订阅，而客户端不能直接触发事件。
自定义事件
- 定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
- 定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
- 定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。
- 用event关键字定义事件对象，它同时也是一个delegate对象。
- 用+=操作符添加事件到事件队列中（-=操作符移除事件）
- 在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，即不能以public方式调用，但可以被子类继承。名字是OnEventName。一个约定俗称的规定，就是订阅事件的方法的命名，通常为“On事件名”
- 在适当的地方调用事件触发方法触发事件。
public class EventTest
{
//1.定义delegate对象
public delegate void MyEventHandler(object sender, System.EventArgs e);
//2.（定义事件参数类）省略
public class MyEventCls
{
//3.定义事件处理方法，它与delegate对象具有相同的参数和返回值类型
public void MyEventFunc(object sender, System.EventArgs e)
{
Console.WriteLine("My event is ok!");
}
}
//4.用event关键字定义事件对象
private event MyEventHandler myevent;
private MyEventCls myecls;
public EventTest()
{
myecls = new MyEventCls();
//5.用+=操作符将事件添加到队列中
this.myevent += new MyEventHandler(myecls.MyEventFunc);
}
//6.以调用delegate的方式写事件触发函数
protected void OnMyEvent(System.EventArgs e)
{
if (myevent != null)
myevent(this, e);
}
public void RaiseEvent()
{
EventArgs e = new EventArgs();
//7.触发事件
OnMyEvent(e);
}
public static void Main()
{
EventTest et = new EventTest();
et.RaiseEvent();
}
}.Net Framework的编码规范
- 委托类型的名称都应该以EventHandler结束。
- 委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
- 事件的命名为 委托去掉 EventHandler之后剩余的部分。
- 继承自EventArgs的类型应该以EventArgs结尾。
委托、事件与Observer设计模式
假设我们有个高档的热水器，我们给它通上电，当水温超过95度的时候：1、扬声器会开始发出语音，告诉你水的温度；2、液晶屏也会改变水温的显示，来提示水已经快烧开了。
热水器由三部分组成：热水器、警报器、显示器。热水器仅仅负责烧水，它不能发出警报也不能显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。
namespace Delegate
{
// 热水器
public class Heater
{
private int temperature;
public string type = "RealFire 001"; // 添加型号作为演示
public string area = "China Xian"; // 添加产地作为演示
//声明委托
public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
public event BoiledEventHandler Boiled; //声明事件
// 定义BoiledEventArgs类，传递给Observer所感兴趣的信息
public class BoiledEventArgs : EventArgs
{
public readonly int temperature;
public BoiledEventArgs(int temperature)
{
this.temperature = temperature;
}
}
// 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
protected virtual void OnBoiled(BoiledEventArgs e)
{
if (Boiled != null)
{ // 如果有对象注册
Boiled(this, e); // 调用所有注册对象的方法
}
}
// 烧水
public void BoilWater()
{
for (int i = 0; i <= 100; i++)
{
temperature = i;
if (temperature > 95)
{
//建立BoiledEventArgs 对象
BoiledEventArgs e = new BoiledEventArgs(temperature);
OnBoiled(e); // 调用 OnBolied方法
}
}
}
}
// 警报器
public class Alarm
{
public void MakeAlert(Object sender, Heater.BoiledEventArgs e)
{
Heater heater = (Heater)sender; //这里是不是很熟悉呢？
//访问 sender 中的公共字段
Console.WriteLine("Alarm：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Alarm: 嘀嘀嘀，水已经 {0} 度了：", e.temperature);
Console.WriteLine();
}
}
// 显示器
public class Display
{
public static void ShowMsg(Object sender, Heater.BoiledEventArgs e)
{ //静态方法
Heater heater = (Heater)sender;
Console.WriteLine("Display：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", e.temperature);
Console.WriteLine();
}
}
class Program
{
static void Main()
{
Heater heater = new Heater();
Alarm alarm = new Alarm();
heater.Boiled += alarm.MakeAlert; //注册方法
heater.Boiled += (new Alarm()).MakeAlert; //给匿名对象注册方法
heater.Boiled += newHeater.BoiledEventHandler(alarm.MakeAlert); //也可以这么注册
heater.Boiled += Display.ShowMsg; //注册静态方法
heater.BoilWater(); //烧水，会自动调用注册过对象的方法
}
}
}如何让事件只允许一个客户订阅？
方法一：将事件声明为private的，然后提供两个方法来进行注册和取消注册
public class Publishser
{
// 声明一个私有事件
private event GeneralEventHandler NumberChanged;//将NumberChanged声明为委托变量还是事件都无所谓了，因为它是私有的
// 注册事件
public void Register(GeneralEventHandler method)
{
NumberChanged = method;//“=”，而非“+=”，通过这种方式就避免了多个方法注册
}
// 取消注册
public void UnRegister(GeneralEventHandler method)
{
NumberChanged -= method;//即使method方法没有进行过注册，也不会抛出异常，仅仅是不会产生任何效果而已。
}
public void DoSomething()
{
if (NumberChanged != null)
{
// 触发事件
string rtn = NumberChanged();
Console.WriteLine("Return: {0}", rtn);
}
}
}方法二：C#中提供了一种叫事件访问器（Event Accessor）的东西，它用来封装委托变量。
class Program
{
static void Main(string[] args)
{
Publishser pub = new Publishser();
Subscriber1 sub1 = new Subscriber1();
Subscriber2 sub2 = new Subscriber2();
pub.NumberChanged -= sub1.OnNumberChanged; // 不会有任何反应
pub.NumberChanged += sub2.OnNumberChanged; // 注册了sub2
pub.NumberChanged += sub1.OnNumberChanged; // sub1将sub2的覆盖掉了
pub.DoSomething();// 触发事件
}
}
// 定义委托
public delegate string GeneralEventHandler();
// 定义事件发布者
public class Publishser
{
// 声明一个委托变量
private GeneralEventHandler numberChanged;
// 事件访问器的定义
public event GeneralEventHandler NumberChanged
{
add
{
numberChanged = value;
}
remove
{
numberChanged -= value;
}
}
public void DoSomething()
{
if (numberChanged != null)
{
numberChanged();// 通过委托变量触发事件
}
}
}
// 定义事件订阅者
public class Subscriber1
{
public string OnNumberChanged()
{
Console.WriteLine("Subscriber1 Invoked!");
return "Subscriber1";
}
}
public class Subscriber2 {/* 与上类同，略 */}