委托的用法很多:一般是用于声明事件和回调的委托,还可以是用于代表方法标签的委托.
书本上的委托只是对委托的定义与具体怎样调用问题，没有涉及到委托的真正实用的地方。其实委托是与事件和回调
一起来使用的，你可以看一下C#异步调用，与多线程处理里等就可以看到委托的作用了。
下面是别人的理解我觉得还是比较好的：
1)有了委托你就可以把方法看作像常数一样,而委托就是该常数类型的变量.
从这个角度看来用于声明事件的委托就是声明这个事件触发以后所调用的方法的标签或者特征.只有符合该标签(参数个数和参数类型)的方法才可以做为该用于该事件的回调.
一个事件触发了,你可能需要用多个方法处理该事件或者说该事件调用了多个方法(每个事件的实例都有一个需要调用的方法列表,当事件触发它会逐个调用列表中的每个方法)
2)通过使用委托你可以实现对方法变化的封装.
打个比方:如果你骑自行车,你需要有骑自行车的方法DriveBike().如果你骑摩托车你需要有骑摩托车的方法.现在你有一个方法DriveMoto.现在你需要定义一个方法,实现你骑(自行车或者摩托车)到某地DriveTo(地点,骑的方式)
骑的方式这里其实就是委托.在使用的时候,如果你是骑自行车你就用DriveBike实例化委托的实例带入DriveTo方法,如果你骑摩托车你就用DriveMoto实例化"骑的方式"这个委托带入DriveTo方法.
B. C＃中的委托到底是什么概念
委托,简单理解是这样的.
比如您要管您的孩子,把孩子送进了幼儿园.
OK.此时您就把您的孩子委托给了幼儿园.
当幼儿园放学,将孩子交还给您的手中.则是委托的回调.
当然我这里的例子是说异步委托调用.您也可以同步.
什么是同步委托调用?
您去银行存钱.把钱给柜员.他们帮你点钞.存款然后给您存折或卡.
那么您就相当于把钱委托给了柜员让他去执行存钱的这个函数.
明白了么?
Delegate
delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它"只能持有与它的签名相匹配的方法的引用"。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数委托和事件在 .Net Framework中的应用非常广泛指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。
实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：
1． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。
2． 创建delegate对象，并"将你想要传递的函数作为参数传入"。
3． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。
using System;
public class MyDelegateTest
{
// 步骤1，声明delegate对象
public delegate void MyDelegate(string name);
// 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
public static void MyDelegateFunc(string name)
{
Console.WriteLine("Hello, ", name);
}
public static void Main()
{
// 步骤2，创建delegate对象(实例？？)
MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
// 步骤3，调用delegate
md("sam1111");
}
}
输出结果是：Hello, sam1111
了解了delegate，下面我们来看看，在C#中对事件是如何处理的。
C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
1．定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2．定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
3．定义"事件处理方法，它应当与delegate对象具有相同的参数和返回值类型"。
4．用event关键字定义事件对象，它同时也是一个delegate对象。
5．用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6．在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7． 在适当的地方调用事件触发方法触发事件。
下面是一个简单的例子：
using System;
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();
Console.Write("Please input ''a'':");
string s = Console.ReadLine();
if(s == "a")
{
et.RaiseEvent();
}
else
{
Console.WriteLine("Error");
}
}
}
输出结果如下，红色为用户的输入：
Please input ‘a’: a
My event is ok!
C. c#委托链的问题
你的委托d1上的确已经挂上了两个方法，当d1被调用的时候，那两个方法也的确都被触发调用到了。
不过多个方法有多个返回值，而只有一个变量来接受，所以后面被调用的方法的返回值，就把前面方法的返回值覆盖掉了。换句话说，前面的返回值都被丢弃掉了。
这也是定义事件委托的时采用void作为返回值的原因。
【回答补充】
你可以去看看系统类库提供的委托/事件，都是void返回类型的。
如果你非要做一个带返回值的委托，那可以这样做了：
......
public string CreateDelegate()
{
Class1 c1 = new Class1();
MyDelegate d1 = new MyDelegate(c1.delegateMethod1);
d1 += c1.delegateMethod2;
string d = "";
foreach (MyDelegate x in d1.GetInvocationList())
{
d += x("Hello World");
}
return d;
}
......
D. c# 委托是怎么回事怎么用
让我来告诉你吧
委托是什么？委托是函数指针。函数指针是什么？是能够运行某（几）个函数（方法）的代码。
举个例子
void static main(){
do();
}
void static do(){
int a = 0;
}
这个好理解吧。。。在main函数内调用do函数。
能够这样写，是因为do的代码（int a = 0;)是已知的。但是，假如在main函数内要调用do函数，却不知道do函数的内容是怎样的，该怎么办呢？
void static main(Adelegate do){
do();
}
do就是一个委托。我们不知道do是怎样写的，我们只知道do函数的参数为空。这就是所谓函数指针--仅在运行时才知道函数的代码。
补充-----------------------------------
比如说windows消息循环就是这种模式。
举个例子。
假如你是微软，你写了一个button控件，他的功能是：当鼠标点击时做点什么。代码可能像这样
while(true){
do();//做点什么
}
问题是：微软怎么知道你要做点什么呢？1000个程序员可以给出1000个答案。
程序员a想显示一条信息，程序员b想打开一个网站。。。
因此，微软不可能自己实现do方法，把它交给人家去做吧！
于是代码改为
public ClickedEventHandler OnClick();//ClickedEventHandler是一个委托
while(true){
if (OnClick != null)
OnClick();
}
程序员a就能这样写代码了：
Button b = new Button();
b.OnClick += new ClickedEventHandler(do());
.................
privte void do(){
MessageBox.Show("haha");
}
点击按钮时，就可以看到'haha'字样了。
当然，不是所有委托都要表示成事件，但事件确是最典型的委托。
E. C# 中 用委托有什么好处 它起什么作用
什么是委托
首先要知道什么是委托，用最通俗易懂的话来讲，你就可以把委托看成是用来执行方法（函数）的一个东西。
如何使用委托
在使用委托的时候，你可以像对待一个类一样对待它。即先声明，再实例化。只是有点不同，类在实例化之后叫对象或实例，但委托在实例化后仍叫委托。
声明，如：
1 namespace Vczx.ProCSharp.Exc
2 {
3 delegate double MathsOp( double x );
4 //class defination here
5 }
这就声明了一个委托，意义：任何一个返回值为double，且只有一个形参为double的函数，都可以用这个委托来调用。
注意：委托的声明位置在namespace里面，类的外面。其实，委托的声明也可以在类的里面，甚至是任何一个可以声明类的地方。
实例化：
首先我们要先有一个满足委托声明的方法，假设一个返回一个数的2倍的方法：
1class MathsOperations
2{
3 public static double MultiplyBy2( double value )
4 {
5 return value * 2;
6 }
7}
有了这样一个方法，我们就可以实例化一个委托了：
MathsOp operation = new MathsOp( MathsOperations.MultiplyBy2 );
在实例化一个委托时，要给它一个参数，这个参数就是委托执行的方法，它可以是静态方法，也可以是实例方法（这一点有别于函数指针，函数指针只能调用静态方法），如：
MathsOp operation = new MathsOp( new Class1().Method1 );
在实例化完一个委托之后，就可以用这个委托来调用方法了：
double result = operation( 1.23 );
例子代码：
1namespace Vczx.ProCSharp.Exc
2{
3 delegate double MathsOp( double x );
4 class Start
5 {
6 public class MyDelegate
7 {
8 public static double MultiplyBy2( double x )
9 {
10 return x * 2;
11 }
12 }
13 [STAThread]
14 static void Main(string[] args)
15 {
16 MathsOp operation = new MathsOp( MyDelegate.MultiplyBy2 );
17 double x = 1.23;
18 double result = operation( x );
19 Console.WriteLine( "{0} multiply by 2 is {1}", x, result );
20 Console.Read();
21 }
22 }
23}
多路广播委托
前面使用的委托只包含一个方法调用。调用委托的次数与调用方法的次数相同。如果要调用多个方法，就需要多次显示调用这个委托。其实委托也可以包含多个方法，这种委托就是多路广播委托。多路广播委托派生于System.MulticastDelegate，它的Combine方法允许把多个方法调用链接在一起，我们可以通过+=来向委托添加调用方法，也可以用-=删除其中的调用方法。如：
1namespace Vczx.ProCSharp.Exc
2{
3 public class MyDelegate
4 {
5 public static void MultiplyBy2( double value )
6 {
7 double result = value * 2;
8 Console.WriteLine( "Multiplying by 2: {0} gives {1}", value, result );
9 }
10
11 public static void Squre( double value )
12 {
13 double result = value * value;
14 Console.WriteLine( "Squaring: {0} gives {1}", value, result );
15 }
16 }
17
18 delegate void MathsOp( double x );
19
20 class Start
21 {
22 [STAThread]
23 static void Main(string[] args)
24 {
25 MathsOp operation = new MathsOp( MyDelegate.MultiplyBy2 );
26 operation += new MathsOp( MyDelegate.Squre );
27 double x = 1.23;
28 operation( x );
29
30 operation -= new MathsOp( MyDelegate.MultiplyBy2 );
31 operation( x );
32
33 Console.Read();
34 }
35 }
36}
输出：
Multiplying by 2: 1.23 gives 2.46
Squaring: 1.23 gives 1.5129
Squaring: 1.23 gives 1.5129
注意，多路广播委托声明时必须返回void，否则返回值不知道应该送回什么地方。对此，我做了一个测试：如果不将委托的声明返回void，则返回值返回的是最后一个链入委托链的方法的返回值，编译不会出错。
为什么要用委托
使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码，而不必在编译时知道将调用哪个方法。与C或C++中的函数指针不同，委托是面向对象，而且是类型安全的。
F. C#中通过委托来调用对象方法的基本过程
delegate翻译过来是委托！
在C#中使用一个类时，分两个阶段。首先需要定义这个类，即告诉编译器这个类由什么字段和方法组成。然后(除非只使用静态方法)实例化类的一个对象。使用委托时，也需要经过这两个步骤。首先定义要使用的委托，对于委托，定义它就是告诉编译器这种类型代表了哪种类型的方法，然后创建该委托的一个或多个实例。
定义委托的语法如下：
delegate void VoidOperation(uint x);
在这个示例中，定义了一个委托VoidOperation，并指定该委托的每个实例都包含一个方法的细节，该方法带有一个uint参数，并返回void。理解委托的一个要点是它们的类型安全性非常高。在定义委托时，必须给出它所代表的方法的全部细节。
提示：
理解委托的一种好方式是把委托的作用当作是给方法签名指定名称。
假定要定义一个委托TwoLongsOp ，该委托代表的函数有两个long型参数，返回类型为double型，可以编写如下代码：
delegate double TwoLongsOp(long first, long second);
或者定义一个委托，它代表的方法不带参数，返回一个string型的值，则可以编写如下代码：
delegate string GetAString();
其语法类似于方法的定义，但没有方法体，定义的前面要加上关键字delegate。因为定义委托基本上是定义一个新类，所以可以在定义类的任何地方定义委托，既可以在另一个类的内部定义，也可以在任何类的外部定义，还可以在命名空间中把委托定义为顶层对象。根据定义的可见性，可以在委托定义上添加一般的访问修饰符：public、 private和 protected等：
public delegate string GetAString();
注意：
实际上，“定义一个委托”是指“定义一个新类”。委托实现为派生于基类System.MulticastDelegate的类，System.MulticastDelegate又派生于基类System.Delegate。C#编译器知道这个类，使用其委托语法，因此我们不需要了解这个类的具体执行情况，这是C#与基类共同合作，使编程更易完成的另一个示例。
定义好委托后，就可以创建它的一个实例，以存储特定方法的细节。
注意：
此处，在术语方面有一个问题。类有两个不同的术语:“类”表示较广义的定义，“对象”表示类的实例。但委托只有一个术语。在创建委托的实例时，所创建的委托的实例仍称为委托。您需要从上下文中确定委托的确切含义。
下面的代码段说明了如何使用委托。这是在int上调用ToString()方法的一种相当冗长的方式：
private delegate string GetAString();
static void Main(string[] args)
{
int x = 40;
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("String is" + firstStringMethod());
// With firstStringMethod initialized to x.ToString(),
// the above statement is equivalent to saying
// Console.WriteLine("String is" + x.ToString());
在这段代码中，实例化了类型为GetAString的一个委托，并对它进行初始化，使它引用整型变量x的ToString()方法。在C#中，委托在语法上总是带有一个参数的构造函数，这个参数就是委托引用的方法。这个方法必须匹配最初定义委托时的签名。所以在这个示例中，如果用不带参数、返回一个字符串的方法来初始化firstStringMethod，就会产生一个编译错误。注意，int.ToString()是一个实例方法(不是静态方法)，所以需要指定实例(x)和方法名来正确初始化委托。
下一行代码使用这个委托来显示字符串。在任何代码中，都应提供委托实例的名称，后面的括号中应包含调用该委托中的方法时使用的参数。所以在上面的代码中，Console.WriteLine()语句完全等价于注释语句中的代码行。
委托的一个特征是它们的类型是安全的，可以确保被调用的方法签名是正确的。但有趣的是，它们不关心调用该方法的是什么类型的对象，甚至不考虑该方法是静态方法，还是实例方法。
提示：
给定委托的实例可以表示任何类型的任何对象上的实例方法或静态方法—— 只要方法的特征匹配于委托的特征即可。
为了说明这一点，我们扩展上面的代码，让它使用firstStringMethod委托在另一个对象上调用其他两个方法，其中一个方法是实例方法，另一个方法是静态方法。为此，再次使用本章前面定义的Currency结构。
struct Currency
{
public uint Dollars;
public ushort Cents;
public Currency(uint dollars, ushort cents)
{
this.Dollars = dollars;
this.Cents = cents;
}
public override string ToString()
{
return string.Format("$.", Dollars,Cents);
}
public static explicit operator Currency (float value)
{
checked
{
uint dollars =(uint)value;
ushort cents =(ushort)((value-dollars)*100);
return new Currency(dollars,cents);
}
}
public static implicit operator float (Currency value)
{
return value.Dollars + (value.Cents/100.0f);
}
public static implicit operator Currency (uint value)
{
return new Currency(value, 0);
}
public static implicit operator uint (Currency value)
{
return value.Dollars;
}
}
Currency结构已经有了自己的ToString()重载方法。为了说明如何使用带有静态方法的委托，再增加一个静态方法，其签名与Currency的签名相同：
struct Currency
{
public static string GetCurrencyUnit()
{
return "Dollar";
}
下面使用GetAString 实例，代码如下所示：
private delegate string GetAString();
static void Main(string[] args)
{
int x = 40;
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("String is " + firstStringMethod());
Currency balance = new Currency(34, 50);
firstStringMethod = new GetAString(balance.ToString);
Console.WriteLine("String is " + firstStringMethod());
firstStringMethod = new GetAString(Currency.GetCurrencyUnit);
Console.WriteLine("String is " + firstStringMethod());
这段代码说明了如何通过委托来调用方法，然后重新给委托指定在类的不同实例上执行的不同方法，甚至可以指定静态方法，或者在类的不同类型的实例上执行的方法，只要每个方法的特征匹配于委托定义即可。
但是，我们还没有说明把一个委托传递给另一个方法的具体过程，也没有给出任何有用的结果。调用int和Currency对象的ToString()的方法要比使用委托直观得多！在真正领会到委托的用途前，需要用一个相当复杂的示例来说明委托的本质。下面就是两个委托的示例。第一个示例仅使用委托来调用两个不同的操作，说明了如何把委托传递给方法，如何使用委托数组，但这仍没有很好地说明没有委托，就不能完成很多简单的工作。第二个示例就复杂得多了，它有一个类BubbleSorter，执行一个方法，按照升序排列一个对象数组，这个类没有委托是很难编写出来的。
G. C#委托和方法
委托是一个类型安全的对象，它指向程序中另一个以后会被调用的方法（或多个方法）。通俗的说，委托是一个可以引用方法的对象，当创建一个委托，也就创建一个引用方法的对象，进而就可以调用那个方法，即委托可以调用它所指的方法。
1、定义委托类型
[访问修饰符]delegate 返回类型 委托名（形参）；
2、声明委托对象
委托名 委托实例名；
3、创建委托对象（确定与哪些方法进行绑定）
委托实例名=new 委托名（某个类的方法）
4、使用委托调用方法
委托实例名（实参）
委托注意事项：
1、委托和方法必须具有相同的参数。
2、委托可以调用多个方法，即一个委托对象可以维护一个可调用方法的列表而不是单独的一个方法，称为多路广播（多播）。
3、使用+=和-=运算实现方法的增加和减少
示例
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Delegate;
namespace Delegate
{
public delegate int Call(int num1, int num2);//第一步：定义委托类型
class SimpleMath
{
// 乘法方法
public int Multiply(int num1, int num2)
{
return num1 * num2;
}
// 除法方法
public int Divide(int num1, int num2)
{
return num1 / num2;
}
}
}
class Test
{
static void Main(string[] args)
{
Call objCall;//第二步：声明委托对象
// Math 类的对象
SimpleMath objMath = new SimpleMath();
// 第三步：创建委托对象，将方法与委托关联起来
objCall = new Call(objMath.Multiply);
Call objCall1 = new Call(objMath.Divide);
objCall += objCall1;//向委托增加一个方法
//objCall -= objCall1;//向委托减去一个方法 // 调用委托实例,先执行objMath.Multiply，然后执行objMath.Divide
int result = objCall(5, 3);
System.Console.WriteLine("结果为 {0}", result);
Console.ReadKey();
}
}
写法：
1、委托 委托名=new 委托（会调用的方法名); 委托名（参数）;
2、委托 委托名 =会调用的方法名; 委托名（参数）；
3、匿名方法
委托 委托名=delegate(参数）{会调用的方法体};委托名（参数）；
4、拉姆达表达式
委托 委托名=（（参数1，。。参数n）=>{会调用的方法体}）；委托名（参数）；
5、用Action<T>和Func<T>,第一个无返回值
Func<参数1, 参数2, 返回值> 委托名= ((参数1，参数2) => {带返回值的方法体 });返回值=委托名（参数1，参数2）；
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using @delegate;
namespace @delegate
{
public delegate int Call(int num1, int num2);
class SimpleMath
{
// 乘法方法
public static int Multiply(int num1, int num2)
{
return num1 * num2;
}
// 除法方法
public int Divide(int num1, int num2)
{
return num1 / num2;
}
}
class Test
{
static void Main(string[] args)
{
//--------------------第一种写法------------------------//
//Call objCall = new Call(SimpleMath.Multiply);
//Call objCall1 = new Call(new SimpleMath().Divide);
//--------------------第二种写法------------------------//
//Call objCall = SimpleMath.Multiply;
//Call objCall1 = new SimpleMath().Divide;
//--------------------第三种写法------------------------//
//Call objCall = delegate(int a, int b)
//{
// return a * b;
//};
//Call objCall1 = delegate(int a, int b)
//{
// return a / b;
//};
//--------------------第四种写法------------------------//
//Call objCall =((int a,int b)=> { return a*b;});
//Call objCall1 = ((int a, int b) => { return a / b; });
//--------------------第五种写法------------------------//
Func<int, int, int> objCall = ((a, b) => { return a * b; });
Func<int, int, int> objCall1 = ((a, b) => { return a / b; });
Action<int, int> ob = ((a, b) => { Console.WriteLine(a * b); });
ob(5, 3);
//----------------------------------------------------//
int result = objCall(5, 3);
int result1 = objCall1(5, 3);
System.Console.WriteLine("结果1为 {0},结果2为{1}", result,result1);
Console.ReadKey();
}
}
}
H. C#中委托如何使用
1.委托概述
委托是C#中新加入的一个类型，可以把它想作一个和Class类似的一种类型，和使用类相似，使用一个委托时，需要两个步骤，首先你要定义一个委托，就像是定义一个类一样；然后，你可以创建一个或多个该委托的实例。
定义一个委托的语法是这样的：
[public/protected/private] delegate returnType delegateName(paramtype param1,…)
这是我自己写的，看起来好像有点怪怪的，我来解释一下，private/protected/private是限定词，就不多说了，delegate是申明一个委托的关键词，returnType是一个返回类型，delegateName是一个你给委托起的名字，你可以写任何一个你喜欢的名字，paramtype param1…这个是参数列表。说了这么多可能看起来还是不是很好理解，我是这样认为的，实用点来讲，委托定义就是在一个函数定义中间加入一个delegate的关键词。它的作用类似于你申明一个类：
public class ClassName {…}
创建一个委托的实例：
[public/protected/private] delegateName deleInstanceName = new delegateName(MethodName)
这个类似于实例化一个类，public ClassName instancename = new ClassName(…)，这里有个要注意的地方，即MethodName方法要和delegateName的签名一致。什么是签名一致，就是说MethodName的参数列表，返回值要分别和returnType、(paramtype param1,…)一致。举个例子来说明下：
public delegate string DelegateDemo(string name, int age);
比如我们如上定义了一个委托，就写法来说，其实就是在函数 string DelegateDemo(string name, int age)前面加了一个delegate的关键字，下面我们来用创建一个函数：
public string AgentDemo(string name, int age)
{
string rev = “”;
…
return rev;
}
这个函数是做参数传递给一个DelegateDemo实例的，接下来创建一个DelegateDemo的实例：
DelegateName instanceDemo = new DelegateName(AgentDemo);
这时要说到一致了，即AgentDemo和声明委托时的DelegateDemo（我们姑且将delegate去掉）这两个函数的返回值，参数列表要相同。终于说完了，不知道看的人明不明白。
接下来，我们可以使用这个委托了（调用一个委托），如下：
string name = “cshape”;
int age = 20;
instanceDemo(name, age);
当instanceDemo执行时，会执行AgentDemo函数，instanceDemo相当于C里的一个函数指针，现在这个指针指向AgentDemo的函数入口地址。
2.多点委托
前面提到的委托都只包含对一个方法的调用，如果需要调用多个方法，需要多次显示的调用这个委托，我们还有另的选择，我们可以让一个委托中包含多个方法，这样我们一次显示调用委托，就可以按照顺序连续的调用多个方法。看下面的例子：
public delegate void MultiDelegate(string name);
public void AgentDemo1(string str)
{
Console.WriteLine(str + “this is AgentDemo1\n”);
}
public void AgentDemo2(string s)
{
Console.WriteLine(s + “this is AgentDemo2\n”);
}
MultiDelegate multiDemo = new MultiDelegate(AgentDemo1);
multiDemo += new MultiDelegate(AgentDemo2);
multiDemo(“multiDemo test :”);
输出的结果应该是：
multiDemo test :this is AgentDemo1
mutliDemo test :this is AgentDemo2
可以看到我们一次显示的调用一个委托，它顺序的（按照你添加方法的顺序）执行了方法AgentDemo1和AgentDemo2。这里要注意的有几点：
● 委托支持 +=，-=这样的运算符，对应为添加或去掉一个方法
● 多点委托不可以定义有返回值，因为无法处理多个方法的返回值，所以如果要使用多点委托，应该用void，否则你的编译会返回一个错误
● 多点委托不建议你的参数列表中有OUT的类型，这样只会out最后一个方法的值，其他的值会丢失。
3.委托的理解
首先申明，这只是我举的一个例子，目的是帮助理解委托的过程，其中很多地方都经不起推敲，望大家知悉。言归正传，
你想要吃饭，
但是自己又不会做（委托方不知道实现细节），
你计划找个饭店，叫个回锅肉饭（定义了一个委托）
你决定找常去的那家叫做A的饭店（实例化一个委托）
你打电话给A饭店（委托调用）
A饭店给你做好了你的回锅肉饭（代理函数工作）
饭来了，真好。
4.委托的使用时机
当你需要把一个方法传送给其他方法时，可以考虑使用委托。好像不是很好理解，也可以这样说，当你确定要处理一件事，但又不能确定处理方法时，可以考虑用委托。其实单独的说委托的应用好像有点牵强，委托更多的是在事件中的应用。
5.一个委托的例子
我用两个类来做这个例子，一个类，我称它为委托方，一个类我称它为代理方，代码如下：
using System;
namespace Visen.Demo.Delegate
{
///<summary>
/// StartUp 委托演示中的程序入口，含委托方。
///</summary>
class StartUp
{
#region公用的方法
#region应用程序的主入口点。
///<summary>
///应用程序的主入口点。
///</summary>
[STAThread]
static void Main(string[] args)
{
Console.WriteLine("This is a delegate demo\n");
Visen.Demo.Delegate.Agent ag = new Agent();
//定义一个委托类型的对象
OutMessage singleDele = new OutMessage(ag.ShowMessage);
OutMessage deleStaticMeth = new OutMessage(Agent.SShowMessage);
//定义一个多点委托
OutMessage MultiDele = new OutMessage(ag.ShowMessage);
MultiDele += new OutMessage(Agent.SShowMessage);
singleDele(" delegate instance singleDele");
deleStaticMeth(" delegate instance deleStaticMeth");
MultiDele(" this is a MultiDele");
Console.Read();
}
#endregion应用程序的主入口点。
#endregion公用的方法
#region私用的字段
///<summary>
///定义一个委托类型
///</summary>
private delegate void OutMessage(string msg);
#endregion私有的字段
}
}
下面是代理方：
using System;
namespace Visen.Demo.Delegate
{
///<summary>
/// Agent 类为委托者的代理方，处理委托者委托的事务。
///</summary>
public class Agent
{
#region公用的方法
#region空的构造函数
///<summary>
///空的构造函数
///</summary>
public Agent()
{
}
#endregion空的构造函数
#region显示一条信息到控制台，一个类成员函数作为代理方
///<summary>
///显示一条信息到控制台，一个类成员函数作为代理方
///</summary>
///<param name="msg">显示内容</param>
public void ShowMessage(string msg)
{
Console.WriteLine("Method ShowMessage out:" + msg + "\n");
}
#endregion显示一条信息到控制台，一个类成员函数作为代理方
#region显示一条信息到控制台，一个类静态函数作为代理方
///<summary>
///显示一条信息到控制台，一个类静态函数作为代理方
///</summary>
///<param name="msg">显示信息</param>
public static void SShowMessage(string msg)
{
Console.WriteLine("static Method SShowMessage out:" + msg + "\n");
}
#endregion显示一条信息到控制台，一个类静态函数作为代理方
#endregion公用的方法
}
}
输出为：
This is a delegate demo
Method ShowMessage out: delegate instance singleDele
static Method SShowMessage out: delegate instance deleStaticMeth
Method ShowMessage out: this is a MultiDele
static Method SShowMessage out: this is a MultiDele
可见：方法函数可以是类成员函数，也可以是一个静态成员，只要和委托的签名相同就可以了。
有错的地方，请大家批评指正，谢谢！
I. C#中的委托是什么怎样使用书上的我看不太明白呀，教我一下
这个的确不好理解 说简单点 打个比方就好像按钮的click事件 我们（再.net中)写按钮的事件都事双击按钮 再后台就会自动生成一个按钮的click函数，然后我们就再这个函数里面写该按钮要作的事。其实这就是个委托加事件，委托起的作用就事再把这个事件个这个click函数联系起来。再asp.net中我们会看到这样的例子
this.Button1.Click += new System.EventHandler(this.Button1_Click);这个就是委托。至于具体使用方法 这个不好说 你自己去琢磨。关键是要理解委托能作什么