今天一来是有点空，二来是在博客上偶然看到有关于委托的文章，一时兴起，就自己也写一点心得与大家分享一下。
先看一个例子：
using System;
namespace ConsoleApplication1
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
bool m_isRight = false;
object m_obj = m_isRight?MyWrite("true"):MyWrite("false");
Console.Write(m_obj);
}
static private int MyWrite(object i_string)
{
Console.Write(i_string);
return i_string.ToString().Length;
}
}
}
问输出的结果是什么？有一个刚学习程序设计不久的学生的回答是：
false false
这个结果给我的映像很深，为什么呢？因为我觉得这个不仅仅是学生的一个错误，而更多的是这个学生深入的思考了问题。
因为m_obj是一个对象，所以这个学生理解为：MyWrite()这个函数对象可以直接赋值给m_obj，然后m_obj就当成MyWrite()这个函数来调用，所以他就认为：
Console.Write (m_obj); 等于是：Console.Write (MyWrite(“false”));
这是思维是很有创意的，不是吗？
于是就是C＃里而很多人不好理解的委托了。其实，从使用上讲，它就是一个函数变量！如上面的例子，如果真的是想把MyWrite()做为对象赋值给m_obj会是个什么结果呢？
我觉得我们先得解决以下几个问题，才能正确的把函数当成变量赋值给一个对象：
1、 如果可以给一个对象赋函数值，如何来区别不同的函数？
2、 如何区别它是一个函数赋值，还是一个普通的对象赋值？
3、 如何用这个对象来调用原来的函数？
如果把这几个问题解决了，委托也就明白了一半。
先看问题1，如果可以给一个对象赋函数值，如何来区别不同的函数？
首先应该明白的是：C＃里是可以对一个对象赋函数值的。解决这个问题的办法是先对该对象申明，申明它可以被什么样的函数来赋值，而这个对象申明在C＃里的学名就是委托。
（在C＋＋里称为函数指针申明，相应的对象也就叫做函数指针。Java里也不同的叫法，可惜我不知道。）
而它的语法就是：
delegate [function declare];
这里的function declare就包括了：
1、 函数返回类型，
2、 可用来存放函数的对象名（也就是委托名）
3、 函数参数
所以完整的定义可以是：
delegate int MyDelegate(object I_object);
当然，合法的委托定义可以是：
delegate void MyDelegate();
delegate void MyDelegate(object I_1,object I_2);
…
现在，上面的语法就定义了一个抽象的对象MyDelegate, 注意，这里说的是抽象的对象，也就是说，你不能直接给MyDelegate赋函数，而只能在它的实例上函数，这是C＃里特殊的要求。它的语法是：
MyDelegate m_delegate = new MyDelegate(与MyDelegate申明一致的函数名);
例如，以下是一个完全的，合法的委托申明与实例化一个对象：
delegate int MyDelegate(object i_object);
//
MyDelegate m_delegate = new MyDelegate(MyWrite);
//MyWrite函数如下，它是满足委托的申明的。
static private int MyWrite(object i_string)
{
Console.Write(i_string);
return i_string.ToString().Length;
}
现在我们就很好的解决了第一个问题，如何定义一个对象，使该对象可以把函数当变量来赋给它。而且，可以区别不同的函数类型，主要是通过函数返回值与函数参数来共区别一类函数。
OK，第二个问题：如果有了这样的一个对象后，如何来给它赋一个函数值呢？
其实上面的实例化一个委托对象时，就已经给它赋值了。上面的代码中，m_delegate就已经被赋值MyWrite，因此它已经具有了MyWrite函数的功能。
还有其实它的方法来给它赋值吗？有，在委托的一个应用中，可以看到其它的赋值方法。也就是另一个不好理解的概念：事件！后面会提到。
我们再来看一下最后一个问题：如何通过一个已经赋值好了的委托对象，还调用它上面赋值了的函数。
这个最简单了，当一个委托实例赋了函数对象在上面后，就可以像调用原函数一样的来调用它了。因此，下面是一个会法的调用：基于上面的申明。
m_delegate(“This is a delegate object to call the raw function.”);
它就等同于：
MyWrite(“This is a delegate object to call the raw function.”);
因此，上面的调用与原函数调用一样，会返回一个int结果。
OK，最后看一个完整的例子：
using System;
namespace ConsoleApplication1
{
class Class1
{
//先申明一个委托对象。
delegate int MyDelegate(object i_object);
[STAThread]
static void Main(string[] args)
{
MyDelegate m_delegate = new MyDelegate(MyWrite);
m_delegate("This is a delegate object to call the raw function.");
}
//该函数是满足上面委托对象的申明的。
static private int MyWrite(object i_string)
{
Console.Write(i_string);
return i_string.ToString().Length;
}
}
}
再来讨论一下它的应用：事件！
事件是其于委托的。我们还是先来看最开始的那个例子：
object m_obj = m_isRight?MyWrite("true"):MyWrite("false");
我想把一个函数对象赋值到m_obj上！但上面的委托只能在实例化对象的时候就直接给它赋值了。而现在是，在运行时对一个委托赋函数值。可以做到吗？
同样是有这样的向个问题，当然，前提是我们已经知道有一种对象叫委托，它的实例可以赋函数对象。
下面的问题是：
1、 如果可以在运行时给某个“特殊委托”赋函数对象，如何实现？
2、 运行时，如何知道该“特殊委托”是否已经被赋过函数值？及如何再赋值？
3、 如果可以，能否在一个“特殊委托”上添加多个函数？如果可以，如何删除函数？
下面，我们就针对这几个问题，来讨论一下C＃里的事件，也就是上面的“特殊委托”。（其它语言里是如何实现这些功能的，我就不清楚了。）
首先，C＃里是可以实现在运行时给一个委托动态的赋函数值的，同时也是可以动态的删除已经添加在某个委托上的函数的，它的实现有一点点麻烦，就是要用到另一个对象：事件！event
（申明，你完全可以不把它叫事件，只不过这种动态的添加和删除函数的功能在真实的程序设计中，基本上是与事件相关，所以就叫做事件了。个人想法，呵呵。）
OK，下面是C＃语法，来申明一个“特殊委托”――事件，让它可以动态的添加函数！
下文中，事件是指那些“特殊委托”，它的特殊之外，后面会讲到。而下文中的委托就是前面讲到的，一个特殊的对象，该对象可以把函数当“值”赋给它。
static event MyDelegate m_myevent;
(static 可以用其它的修饰符)
说明一下，这里其实就是申明了一个事件，用event来说明它是事件（特殊委托）的。其实对比实例化一个委托的语法，你可以理解到，它就像是申明了一个委托，只不过个委托加了个event来说明它：
Mydelegate m_delegate;//申明一个委托
event MyDelegate m_myevent;//申明一个事件
很像吧！不是吗？
OK，我们再来看，m_myevent 与m_delegate到底有什么不同的？也就是，事件（特殊委托）到底特殊在什么地方？
1、 事件不是一个可以直接把函数当值一样赋给它的委托。而委托可以直接赋函数，而且是在实例化的时候，赋函数名。
2、 事件只能把一个实例的委托当值赋给它。也就是说：事件是用来管理委托的，进而来管理函数！因为一个实例化的委托一定有一个函数与之对应。
3、 在事件上可以动态的添加与删除委托。而委托上不能动态的添加删除函数。
OK,下面的一个问题，上面事件的申明中，MyDelegate是起什么作用的呢？
还记得前面的委托申明吗？它就是说明了m_myevent在运行时可以动态的以委托的形式赋的函数要与MyDelegate申明的一样！
因此上面的一个实例化是完全合法的。
再理解一下：事件，是用来动态管理委托的，而委托是单一的与一个函数对应的。
现在看第二个问题，运行时，如何知道该“特殊委托”是否已经被赋过函数值？及如何再赋值？
即：如何知道一个事件上已经赋过经过委托过的函数？
前面已经说过，m_myevent没有给它赋值，如何给它赋值呢？它的赋值方法有点怪：
一个实例：
m_myevent += m_delegate;
有点怪吧！这里正好说明了：事件是用来动态管理委托的。把一个委托加在事件上。
当然，你还可以在添加委托的时候直接new一个新的委托：
m_myevent +=new MyDelegate(Class1_m_myevent);//后面的函数名由vs2003生动生成
这就是.net下标准的给事件添加委托的方法，也就是给一个事件添加了一个可调用的函数。确切的说，是一个回调函数（C＋＋的概念）。
OK，下面就如何判断一个事件上是否已经被赋过经过委托的函数：
if(m_myevent==null)
就可以知道了！
那么如何知道一个事件上面有多少个委托呢？也就是多少个委托过的函数？
m_ myevent.GetInvocationList();
可以得到所有的委托！这里应该知道：事件本身是一个对象，当实例化一个事件后，它是有自己的一些方法也成员的。可以查阅MSDN得到更多说明，同样的委托也是一个对象，相关的说明也可以在MSDN里找到。
最后的问题：如何删除一个已经添加在事件上的委托？
太容易而且太有意思了：
m_myevent -= m_delegate;
那么这样的几个问题又来了：
1． 如果这个事件上没有该委托，“减掉”以后会出错吗？不会，放心的减吧。
2． 如何调用这个事件上的委托呢？上面有多个委托，它是怎样运行呢？
调用事件上的委托与调用委托上的函数是完全一样的：你要给出与委托申明一样的函数参数，并且调用会返回与申明一样的数据类型。
最后再回来看这个问题：
object m_obj = m_isRight?MyWrite("true"):MyWrite("false");
如何解决它呢？把一个函数赋给一个对象：一个例示（仅做演示解决这个问题，个人认为这样的做法没有实用意义）
using System;
namespace ConsoleApplication1
{
public class Class4
{
event System.EventHandler m_obj;
public Class4()
{
System.EventHandler m_f1 = new EventHandler(SomeFunc1);
System.EventHandler m_f2 = new EventHandler(SomeFunc2);
bool m_someCondition = false;
m_obj += m_someCondition?m_f1:m_f1;
m_obj(this,null);
}
private void SomeFunc1(object sender, EventArgs args)
{
}
private void SomeFunc2(object sender, EventArgs args)
{
}
}
}
最后看一个完整的例子：
using System;
namespace ConsoleApplication1
{
class Class1
{
//先申明一个委托对象。
delegate int MyDelegate(object i_object);
static event MyDelegate m_myevent;
[STAThread]
static void Main(string[] args)
{
MyDelegate m_delegate = new MyDelegate(MyWrite);
m_delegate("This is a delegate object to call the raw function.");
m_myevent += m_delegate;
m_myevent += new MyDelegate(MyWrite);
m_myevent +=new MyDelegate(Class1_m_myevent);
if(m_myevent!=null)
{
m_myevent("This is a event to call the funcaion on the delegate.");
}
}
//该函数是满足上面委托对象的申明的。
static private int MyWrite(object i_string)
{
Console.WriteLine(i_string);
return i_string.ToString().Length;
}
private static int Class1_m_myevent(object i_object)
{
Console.WriteLine(i_object);
return 0;
}
}
}
我们再来看一个.net下标准的事件驱动模型的例子：
using System;
namespace ConsoleApplication1
{
public delegate void MyEventHandle(object i_sender,object i_arg);
public class Class2
{
public Class2()
{
}
[STAThread]
static void Main2(string[] args)
{
Class3 m_runOject = new Class3();
m_runOject.OnError += new MyEventHandle(m_runOject_OnError);
m_runOject.OnSomeThingHappened += new MyEventHandle(m_runOject_OnSomeThingHappened);
m_runOject.Run();
}
private static void m_runOject_OnError(object i_sender, object i_arg)
{
Console.WriteLine("Error in {0}, arg:{1}",i_sender,i_arg);
Console.WriteLine("Object {0} will stop running.",i_sender);
(i_sender as Class3).Stop();
}
private static void m_runOject_OnSomeThingHappened(object i_sender, object i_arg)
{
Console.WriteLine("Something happended in {0}, arg:{1}",i_sender,i_arg);
}
}
public class Class3
{
public bool m_isStop = false;
public event MyEventHandle OnSomeThingHappened;
public event MyEventHandle OnError;
public Class3()
{
}
public void Run()
{
Random m_rand = new Random();
int m_randomNum = m_rand.Next();
while(!m_isStop)
{
if(m_isStop){break;}
m_randomNum = m_rand.Next(100);
if(m_randomNum%5==0)
{
if(this.OnError!=null)
{
this.OnError(this,m_randomNum);
}
}
else
{
if(this.OnSomeThingHappened!=null)
{
this.OnSomeThingHappened(this,m_randomNum);
}
}
}
}
public void Stop()
{
m_isStop = true;
}
}
}
好了，全部完了！
最后再从另一个角度来理解：函数，委托和事件！
1、 函数，是程序的基本单元，在.net下，有一个很重要的思想，就是：一切对象化！你可把一个int boxing后得到一个object,也可以把一个object unboxing后得到一个int. 可惜，就是没有函数对象化这个概念！？
2、 其实函数也可以对象化！就是通过delegate，委托就是把函数作为对象来处理，使它函数也具有了对象的一些特点。在实例化一个委托的时候，就是把一个函数”boxing”。因此，委托本质上就是一个类！它的初始化参数是一个函数名！不同的委托是不同的类，对应不同类型的函数。
3、 事件是对委托的一个管理封装，它可以很好的动态管理委托，从而完成很多有实用价值的事情，最主要的就是事件！
完全是个人理解，有不同意见，欢迎讨论！
================================
/\_/\
(=^o^=) Wu.Country@侠缘
(~)@(~) 一辈子，用心做一件事！
--------------------------------
Happy Jimmy, keep dreaming!
================================