标签：
委托在底层就是一个函数的指针，委托是事件的基础。
你可以传递引用类型、值类型、但是你有没有需要传一个方法呢？传方法的过程就是委托。
消息类：
public class Message { /// <summary> /// 传引用类型 /// </summary> /// <param name="msg"></param> public static void Send(string msg) { Console.WriteLine("你传递的参数是string：{0}", msg); } /// <summary> /// 传值类型 /// </summary> /// <param name="msg"></param> public static void Send(int msg) { Console.WriteLine("你传递的参数是int：{0}", msg); } /// <summary> /// 利用委托传一个方法过来 /// </summary> /// <param name="msg"></param> public static void Send(Action msg) { ///执行它 msg.Invoke(); // Console.WriteLine("你传递的参数是int：{0}", msg); } }
使用例子：
class Program { static void Main(string[] args) { ///传引用类型的字符串 Message.Send("晚上好！端午节快乐！"); ///传值类型的，int 68 Message.Send(68); ///传一个方法 Message.Send(SendMessage); Console.ReadKey(); } /// <summary> /// 方法 /// </summary> static void SendMessage() { Console.WriteLine("我是 Program 类的 SendMessage 方法"); } }
运行结果：
是不是很有用处：
当两个对象之间的处理结果需要相互通知。（onClick，onLoad等一切的事件，基础都是基于委托），委托实际就是一个观察者模式。其作用是两个对象之间可以通过委托，相互通知消息。
委托的定义：
public class DelegateExample { /// <summary> /// 定义一个方法，方法有0到N个参数，可以有返回值，和无返回值 /// </summary> /// <param name="msg"></param> public void MethodTest(int Ivalue) { } /// <summary> /// 定义另一个委托，委托和方法一样有0到N个参数，可以有返回值，和无返回值 /// </summary> /// <param name="msg"></param> /// <param name="msg2"></param> public delegate int DelegateTest(string msg, string msg2); public void Show() { ///定义委托：委托像 “类” 一样，定义来使用，用 new DelegateTest 来指向方法 DelegateTest delegateTest1 = new DelegateTest(DelegateTest2_Mothod); ///调用委托：将参数给定 delegateTest1.Invoke("aa", "bb"); Console.WriteLine("------------------------------------"); ///直接指向方法 DelegateTest delegateTest2 = DelegateTest2_Mothod; ///不用 Invoke 也可以直接使用 delegateTest1("cc", "dd"); Console.WriteLine("------------------------------------"); ///用 Lambda 表达式来定义一个匿名方法 DelegateTest delegateTest3 = (string msg, string msg2) => { Console.WriteLine("BeginInvoke"); return msg.Length + msg2.Length; }; ///异步来调用 delegateTest3.BeginInvoke("ee", "ff", null, null); Console.WriteLine("------------------------------------"); ///用 Lambda 表达式来定义一个匿名方法 DelegateTest delegateTest4 = (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; }; ///多次指定方法（多播委托） delegateTest4 += (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; }; delegateTest4 += DelegateTest2_Mothod; delegateTest4 += DelegateTest2_Mothod; ///减掉一个 delegateTest4 -= DelegateTest2_Mothod; ///减掉一个匿名委托，实际是不起作用的，因为匿名没有“固定”指向名称，所以不能减掉，下面同样会执行 delegateTest4 -= (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; }; delegateTest4.Invoke("dd", "eee"); } int DelegateTest2_Mothod(string msg, string msg2) { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; } }
执行结果是：
delegateTest1 直接用（delegateTest1("cc", "dd");），Invoke调用，delegateTest1.Invoke("aa", "bb");两次结果完全相同
delegateTest3 begininvoke 是在前面的，结果跑到最后面。异步的原因。
delegateTest4 加了4次委托，减掉2次，但是执行3次，说明了有一次没有减掉。就是匿名没有减掉。
记住委托的作用就是，定义一个方法（函数）的指针。
在编程中，委托是一个非常有用的功能，因为任何异步调用的基础也是委托
.net 框架为我们定义好了两个委托，一个有返回值，一个无返回值，这样我们就免于需要创建委托的重复劳动：
无返回
Action
Action<string>
0-16个参数，无返回值
在系统当中大量使用
有返回
func<int>
fun<string,int> 第一个是参数，最后是返回值
1-17，前面是参数，最后一个是返回值
在系统当中大量使用
1、异步必须要用委托
2、方法像类型一样传递，可以分离业务逻辑
事件的基础就是委托：
事件在系统中使用的非常之多。
定义一个事件：
/// <summary> /// 定义一个事件 /// </summary> public event Action<string> SendEvent;
事件的使用：
static void Main(string[] args) { ///传引用类型的字符串 Message.Send("晚上好！端午节快乐！"); ///传值类型的，int 68 Message.Send(68); ///传一个方法 Message.Send(SendMessage); DelegateExample delegateExample = new DelegateExample(); delegateExample.Show(); ///实例化事件类 MyEvent myevent = new MyEvent(); ///订阅事件 myevent.SendEvent += Myevent_SendEvent; ///执行工作 myevent.Send(string.Format("开始：{0}", DateTime.Now)); Console.ReadKey(); } /// <summary> /// 订阅的处理方法（确定委托需要指针，指向的方法） /// </summary> /// <param name="obj"></param> private static void Myevent_SendEvent(string obj) { Console.WriteLine("返回：{0}", obj); }
事件演示代码：
public class MyEvent { /// <summary> /// 方法的定义 /// </summary> /// <param name="msg"></param> public void MethodDemo(string msg) { } /// <summary> /// 委托的定义，委托在方法修饰符后面加 delegate /// 委托没有实体{} /// </summary> /// <param name="msg"></param> public delegate void delegateDemo(string msg); /// <summary> /// 事件的定义，事件在委托修饰符后面加 event /// </summary> public event delegateDemo eventDemo; /// <summary> /// /// 记住，事件必须以一个委托为基础 /// 定义一个事件，本例中以系统自带的 Action 为基础 /// /// </summary> public event Action<string> SendEvent; public void Send(string msg) { Task.Factory.StartNew(() => { Thread.Sleep(TimeSpan.FromSeconds(15)); ///在 if (SendEvent != null) { SendEvent(string.Format("Task.Factory.StartNew:{0},{1}", DateTime.Now, msg)); } }); } }
运行结果：
委托是一种类型、是一个函数指针、事件就是委托的一个实例
委托加上一个 EVENT 关键字后就变成了事件
事件不能直接赋值。也不能被调用。只能通过+=，-= 来操作委托
委托就是 观察者模式 的实现方法
委托是业务之间逻辑剥离的解决方案。
标签：
原文地址：http://www.cnblogs.com/lystory/p/5566122.html
