委托：委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全
相同的行为。委托方法的调用可以像其他任何方法一样，具有参数和返回值。
与委托的签名（由返回类型和参数组成）匹配的任何可访问类或结构中的任何方法都可
以分配给该委托。方法可以是静态方法，也可以是实例方法。这样就可以通过编程方式
来更改方法调用，还可以向现有类中插入新代码。只要知道委托的签名，便可以分配自
己的委托方法。
特点：
委托类似于 C++ 函数指针，但它们是类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起；例如，可以对一个事件调用多个方法。
方法不必与委托签名完全匹配。
委托也可以用在匿名方法上
例如：
delegate void  delg(int i);//在类外部定义一个委
在main方法里委托引用了一个匿名方法
delg del1 = delegate(int i) { Console.Write("method4:     ");
Console.WriteLine(i); };
 
委托的协变：
（例子中解释）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace text0725lianxi
{
 
    class Program
    {
        static void Main(string[] args)
        {
            Program pro=new Program();
            del del1 = new del(pro.meth1);
            del del2 = new del(pro.meth2);/*委托的协变    
                                                                  （meth2的返回值是minicom型，
                                                                     del2的返回值是computer类型，
                                                                      computer是minicom的父类型，
                                                                     可以把子类型的值赋给父类型）*/

            Console.WriteLine(del1().GetType().ToString());  
            //执行出来是text0725lianxi.computer
            Console.WriteLine(del2().GetType().ToString());  
            //执行出来是text0725lianxi.minicom
        }
        public computer meth1()   //返回值为computer类型的方法
        {
            return new computer();
        }
        public minicom meth2()   //返回值为minicom类型的方法
        {
            return new minicom();
        }
    }
    class computer     //定义computer类
    { }
    class minicom : computer  //定义minicom类，继承自computer类
    { }
    delegate computer del(); //定义返回值为computer类型的委托
}
委托的逆变：
（例子中解释）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace text0725lianxi
{
 
    class computer   //定义一个computer类
    { }
    class minicom : computer   //定义一个minicom类，这个类继承自computer
    { }
    delegate void del(minicom com);    //定义一个委托，他的参数是minicom类型
    class Program
    {
        static void Main(string[] args)
        {
            Program pro = new Program();
            minicom com=new minicom();
        
            del del1 = new del(pro.meth1);//委托的逆变：
                                                        /*  委托del1引用了meth1方法，
                                                        委托的参数是minicom类型
                                                        meth1方法的参数是computer类型
                                                        这样好像是把一个父类型付给了子类型
                                                        * 但实际上是参数的传递并不在这行代码
                                                        * 中进行，而在后面del1（com）中进行，
                                                        * minicom类型的参数先传给del1,但del1
                                                        * 仅仅是个委托，他引用的是方法meth1，
                                                        * 这样参数继续传递给方法meth1， 而
                                                        * meth1方法需要的参数是computer类型，
                                                        * 这个时候就是把子类型 参数赋给了父类
                                                        * 型，是允许的，这个过程就是委托的逆变 */
            del del2 = new del(pro.meth2);
            del1(com);
            //del2(pu);
            del2(com);
        }
        public void meth1(computer com)  //定义一个参数为computer类型的方法
        {
            Console.WriteLine("meth1");
        }
        public void meth2(minicom com)  //定义一个参数为minicom类型的方法
        {
            Console.WriteLine("meth2");
        }
    }
}