托付是寻址方法的.NET版本号。在C++中。函数指针仅仅只是是一个指向内存位置的指针，它不是类型安全的。而.NET托付全然不同，托付是安全类型的类，它定义了返回类型和參数的类型。
当把方法传递给其它方法时，须要使用托付。
C#中使用一个类时，分两个阶段。
首先须要定义这个类，即告诉编译器这个类由什么组成的。然后，实例化一个对象（除非仅仅使用静态方法）。
对于托付也是相似，也须要两个步骤。
首先必须定义要使用的托付。然后必须创建该托付的一个或多个实例。
定义语法：
delegate void IntMethodInoker(int x);
delegate double TwoLongsOp(long first, long second);
delegate string GetString();定义托付基本上是定义一个新类。所以能够在定义类的不论什么同样地方定义托付。即能够在还有一个类的内部定义，能够在不论什么类的外部定义，能够在名称空间中把托付定义为顶层对象。
依据托付定义的可见性，和托付的作用域，能够在托付的定义上应用随意常见的訪问修饰符：public、private、protected等
比如：
public delegate string GetAString();使用托付：
private delegate string GetAString();
static void Main()
{
int x=40;
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("String is {0}",firstStringMethod () );
}由上述代码能够看到。C#的托付在语法上总是接受一个參数的构造函数。这个參数就是托付引用的方法，可是这种方法必须匹配最初定义托付时的签名。
实际上。给托付实例提供圆括号与调用托付类的Invoke()方法全然同样。
使用Invoke完毕一个托付方法的封送。就相似于使用SendMessage方法来给界面线程发送消息，是一个同步方法。也就是说在Invoke封送的方法被运行完毕前，Invoke方法不会返回，从而调用者线程将被堵塞。
由于firstStringMethod 是一个托付类型的变量，所以C#编译器会用firstStringMethod.Invoke()取代firstStringMethod ()。
firstStringMethod();
firstStringMethod.Invoke();为了降低输入量。仅仅须要托付实例，就能够仅仅传递地址的名称，即托付判断。
GetAString firstStringMethod = new GetAString(x.ToString);
GetAString firstStringMethod = x.ToString;注意：输入行事不能是x.ToString()。也不能把它传给托付变量。x.ToString表示把方法的地址赋予托付变量。
多播托付：
托付能够包括多个方法，这样的托付称为多播托付。假设调用多播托付。就能够按顺序连续调用多个方法。可是，托付的签名必须返回void。否则仅仅能得到托付调用的最后一个方法的结果。
多播托付演示样例程：
delegate void Delegate_Multicast(int x, int y);
Class Class2
{
static void Method1(int x, int y)
{
Console.WriteLine("You r in Method 1");
}
static void Method2(int x, int y)
{
Console.WriteLine("You r in Method 2");
}
public static void Main()
{
Delegate_Multicast func = new Delegate_Multicast(Method1);
func += new Delegate_Multicast(Method2);
func(1,2); // Method1 and Method2 are called
func -= new Delegate_Multicast(Method1);
func(2,3); // Only Method2 is called
}
} 解析：
上面的演示样例程序分别定义了名为method1 和 method2的两个接受整型參数、返回类型为void的方法。
在Main函数里使用以下的声明创建托付对象：
Delegate_Multicast func = new Delegate_Multicast(Method1);
然后使用+= 来加入托付，使用-=来移除托付。
合并托付：
托付对象的一个用途在于，能够使用 + 运算符将它们分配给一个要成为多路广播托付的托付实例。
组合的托付可调用组成它的那两个托付。
仅仅有同样类型的托付才干够组合。
- 运算符可用来从组合的托付移除组件托付。
delegate void Del(string s);
class TestClass
{
static void Hello(string s)
{
System.Console.WriteLine(" Hello, {0}!", s);
}
static void Goodbye(string s)
{
System.Console.WriteLine(" Goodbye, {0}!", s);
}
static void Main()
{
Del a, b, c, d;
// Create the delegate object a that references
// the method Hello:
a = Hello;
// Create the delegate object b that references
// the method Goodbye:
b = Goodbye;
// The two delegates, a and b, are composed to form c:
c = a + b;
// Remove a from the composed delegate, leaving d,
// which calls only the method Goodbye:
d = c - a;
System.Console.WriteLine("Invoking delegate a:");
a("A");
System.Console.WriteLine("Invoking delegate b:");
b("B");
System.Console.WriteLine("Invoking delegate c:");
c("C");
System.Console.WriteLine("Invoking delegate d:");
d("D");
}
}
/*-------------------------
输出
Invoking delegate a:
Hello, A!
Invoking delegate b:
Goodbye, B!
Invoking delegate c:
Hello, C!
Goodbye, C!
Invoking delegate d:
Goodbye, D!
----------------------*/匿名方法：
到眼下为止。要想使用托付工作。方法必须已经存在。可是还有还有一种使用托付的方法：即通过匿名方法。
匿名方法是用作托付的參数的一段代码。
用匿名方法定义托付的语法与前面的定义并没有差别。
但在实例化的时候就有了差别了。
假设使用匿名方法。则不必创建单独的方法，因此降低了实例化托付所需的编码系统开销。
比如。假设创建方法所需的系统开销是不必要的，在托付的位置指定代码块就非常实用。启动新线程即是一个非常好的演示样例。无需为托付创建很多其它方法，线程类就可以创建一个线程而且包括该线程运行的代码。
void StartThread()
{
System.Threading.Thread t1 = new System.Threading.Thread
(delegate()
{
System.Console.Write("Hello, ");
System.Console.WriteLine("World!");
});
t1.Start();
}托付类型派生自 .NET Framework 中的 Delegate 类。
托付类型是封装的，它们不能派生出其它类，也不能从 Delegate 派生出自己定义类。 由于实例化的托付是一个对象。因此能够作为參数传递或分配给一个属性。 这同意方法作为參数接受托付并在稍后调用托付。
这被称为异步回调，是在长进程完毕时通知调用方的经常用法。 当以这样的方式使用托付时。使用托付的代码不须要知道要使用的实现方法。 功能相似于封装接口提供的功能。