委托（delegate）是一种引用类型，我们在处理他的时候要当作类来看待而不是方法，说白了委托就是对方法或者方法列表的引用，调用一个委托实例就好像是调用c++中的指针一样，他封装了对制定方法的引用，或者说委托起到的是桥梁的作用，实例后的委托对象会将给定的参数传递给他所回调的方法，并去执行方法。

       看一个简单的例子：

     //声明一个委托
    delegate int myDelegateHandler(int a, int b);

    public class A
    {
        //静态的处理方法
        public static int M1(int a, int b)
        {
            int c = 0;
            c = a + b;
            return c;
        }
    }
    //入口类
    public class B
    {
        public static void Main()
        {
            //实例一个委托
            myDelegateHandler mdh = new myDelegateHandler(A.M1);
            //调用委托
            int sum = mdh(2, 2);
            Console.WriteLine(sum.ToString());

        }
    }

    上面是一个非常简单的例子，具体的实现步骤：

1、 先声明个委托实例  ；

2、然后提供要处理的方法；

3、再实例化委托（把委托看作是类的话，实例化委托就不难理解了，其参数是要处理的方法，这里的方法 不用加括号，实例化的过程就是装载方法的过程，就好像需要参数的构造函数一样）实例化后的委托对象就好比是c++中的指针，它本身就是封装了方法的对象；

4、最后我们调用委托对象就好比是调用了被封装方法本身，调用时的参数也就传给了被封装的方法。

5、需要注意的是 所声明的委托无论是 参数个数，参数类型，返回值类型 都要和所要封装的方法保持一致，当调用委托实例对象时，所传入的参数也要保持一致 ，否则会出现错误。 

实例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CSharp_委托的学习
{
    class Program
    {
        ////1、什么是委托及最简单的委托定义与实例化
        ////如果我们需要把方法当做参数来传递的话，我们就需要用到委托。委托是一个类型，可以指向一个方法。委托需要定义和实例化。
        ////最简单的委托：
        //private delegate void Print();//定义了一个无返回类型、名称为Print的委托。
        //static void Main(string[] args)
        //{
        //    Print print1 = printStr;//用Print类型的委托实例化了一个委托print1，并指向函数printStr。
        //    print1();//调用委托即相当于调用函数printStr();
        //}
        //static void printStr()
        //{
        //    Console.WriteLine("hello world");
        //}
        ////2、委托可以作为参数传递
        //private delegate void Print();//定义了一个无返回类型、名称为Print的委托。
        //static void Main(string[] args)
        //{
        //    Print print1 = printStr;//用Print类型的委托实例化了一个委托print1，并指向函数printStr。
        //    printDelegateMethod(print1);//print1作为参数传递，最终调用函数printStr()
        //}
        //static void printStr()
        //{
        //    Console.WriteLine("hello world");
        //}
        //static void printDelegateMethod(Print printTemp)
        //{
        //    printTemp();
        //}
        ////3、内置委托：Action类型委托
        ////Action类型委托的特点：无返回类型的委托即返回类型为void
        ////定义格式：T表示方法的参数，最多不超过16个
        ////Action
        ////Action<in T>
        ////Action<in T1, in T2>
        ////Action<in T1, in T2....in T16>
        //static void Main(string[] args)
        //{
        //    Action a1 = printStr;//用Action类型委托实例化一个委托a1，并指向printStr
        //    a1();//调用a1即相当于调用函数printStr
        //    Action<string> a2 = printOneStr;//用Action类型委托实例化一个含有一个string类型参数的委托a2，并指向printOneStr
        //    a2("hello, I Invoke printOneStr");//调用a2即相当于调用函数printOneStr
        //    Action<string, int> a3 = printTwoStr;
        //    a3("剩余血量：", 50);
        //}
        //static void printStr()
        //{
        //    Console.WriteLine("hello world");
        //}
        //static void printOneStr(string s1)
        //{
        //    Console.WriteLine(s1);
        //}
        //static void printTwoStr(string s1, int i2)
        //{
        //    Console.WriteLine(s1+i2);
        //}
        ////3、内置委托：Func类型委托
        ////Func类型委托的特点：带有一个返回值的委托
        ////定义格式：T表示方法的参数, TReturn表示返回值类型，T最多不超过16个
        ////Func
        ////Func<out TReturn>
        ////Func<in T1, in T2>
        ////Func<in T1, in T2....in T16, out TReturn>
        //static void Main(string[] args)
        //{
        //    Func<int> a1 = Test1;//用Func类型委托实例化一个委托a1，并指向Test1
        //    Console.WriteLine(a1());//调用a1即相当于调用函数Test1
        //    Func<float, string> a2 = Test2;//用Func类型委托实例化一个含有一个float类型参数，返回类型为string的委托a2，并指向Test2
        //    Console.WriteLine(a2(3.14f));//调用a2即相当于调用函数Test2
        //    Func<string, int, string> a3 = Test3;
        //    Console.WriteLine(a3("剩余血量：", 50));
        //}
        //static int Test1()
        //{
        //    return 1;
        //}
        //static string Test2(float f1)
        //{
        //    return f1.ToString();
        //}
        //static string Test3(string s1, int i2)
        //{
        //    return (s1 + i2);
        //}
        //多播委托：委托里包含多个方法（函数），调用多播委托可以同时调用这些方法
        private delegate void Print();//定义了一个无返回类型、名称为Print的委托。
        static void Main(string[] args)
        {
            Print print = print1;//用Print类型的委托实例化了一个委托print，并指向函数print1。
            print();//调用委托print即相当于调用函数print1();
            print += print2;//并没有直接指向print2，而是加上print2
            print();//调用委托print即相当于调用函数print1()和print2();
        }
        static void print1()
        {
            Console.WriteLine("hello ");
        }
        static void print2()
        {
            Console.WriteLine("world");
        }
    }
}

• C#
• 委托