DOTNETc# 委托 delegates

首先来理解下委托的定义
委托是一种引用方法的类型。也就是分配在一旦为委托分配栈中，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值，如下面的示例所示：
 
C# 
public delegate int PerformCalculation(int x, int y);
与委托的签名（由返回类型和参数组成）匹配的任何方法都可以分配给该委托。这样就可以通过编程方式来更改方法调用，还可以向现有类中插入新代码。只要知道委托的签名，便可以分配自己的委托方法。
将方法作为参数进行引用的能力使委托成为定义回调方法的理想选择。 
先看下面的实例

/*
 * Title：About Deleages add Event 
 *Author:stephenzhou
 *datetime ：2012-06-29
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace classandstruct
{
    class Program
    {
        static void Main(string[] args)
        {
            classandstruct.Program sr = new Program();  //必须要先实例化本身的这个类，因为在这个类中Main静态方法的引用了非静态方法 除非把后面锁//引用的方法全部改成静态方法 否则必须实话下这个类
            sr.Print(SelPrit.Printone, "str");

        }
        通过枚举来选择调用方法///
        public void Print(SelPrit Sel, string str)
        {
            switch (Sel)
            {
                case SelPrit.Printone:
                    Printone(str);
                    break;

                case SelPrit.Printtwo:
                    Printtwo(str);
                    break;

                case SelPrit.Printthr:
                    Printthr(str);
                    break;
            }
            Console.ReadLine();


        }
        void Printone(string str)
        {
            Console.WriteLine("Printone   " + str);

        }
        void Printtwo(string str)
        {
            Console.WriteLine("Printtwo  " + str);

        }
        void Printthr(string str)
        {
            Console.WriteLine("Printthr  " + str);

        }

        public enum SelPrit
        {
            Printone, Printtwo, Printthr
        }
    }

}

 如果以后有别的方法新增了 也要加入到用户选择的时候，这个时候还的在枚举新增一个了。 这样有点麻烦。
如下EXP实例 用委托来解决问题

/*
 * Title：About Deleages add Event 
 *Author:stephenzhou
 *datetime ：2012-06-29
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication10
{
    public delegate void DeledateSel(string name); //申明一个委托 
    class Program
    {
        void Printone(string str)
        {
            Console.WriteLine("Printone " + str);
        }
        void Printtwo(string str)
        {
            Console.WriteLine("Printtwo " + str);
        }
        void Printthr(string str)
        {
            Console.WriteLine("Printthr " + str);
        }
        void SelePrint(DeledateSel SelPrint, string str) //委托类型作为参数进来
        {
            SelPrint(str);
        }
        static void Main(string[] args)
        {
            Program pg = new Program();
            pg.SelePrint(pg.Printtwo, "Stephen");
            Console.Read();
        }
    }
}

委托可以看作一个类型。可以把方法作为一个参数传到另外一个方法当中去了。扩展性就远远大于第一种解决方案。 
其实这个解决方案可以看做是

static main(string []args )
{           
            Program pg = new Program();
            pg.Printtwo("Stephen");
            Console.Read();
}

这样看是是不是更加明显了呢？？


既然委托和一般的数据类型比如string类型一样 那么又可以这样改

static void Main(string[] args)
        {


            Program pg = new Program();
            DeledateSel prone, prtwo, prthr;
            prone = pg.Printone;
            prtwo = pg.Printtwo;
            prthr = pg.Printthr;
            pg.SelePrint(prtwo, "Stephen");

            Console.Read();


        }

 这样就完全把委托当做一个类来看。委托的变量prone, prtwo, prthr 分别可以赋值。然后作为参数传进来。
给一个委托赋值3次看下

static void Main(string[] args)
        {


            Program pg = new Program();
            DeledateSel prone ;
            prone = pg.Printone;
            prone += pg.Printtwo;
            prone += pg.Printthr;
            pg.SelePrint(prone, "Stephen");


            Console.Read();


        }

输出结果如下
Printone   Stephen
Printtwo  Stephen
Printthr  Stephen




 很明显，这个委托里有三个值，所以委托分别执行了三次。  委托赋值可以累加，是否可以递减呢？ 看以下代码执行结果。

    static void Main(string[] args)
        {

            Program pg = new Program();
            DeledateSel prone ;
            prone = pg.Printone;
            prone += pg.Printtwo;
            prone -= pg.Printtwo;
            pg.SelePrint(prone, "Stephen");

            Console.Read();

        }
    }

执行结果如下
  
Printone   Stephen







使用委托可以把多个方法绑定到同一个委托变量当中去，当调用这个委托变量的时候就会依次调用所绑定的方法。
总结，委托就是一个类型，什么类型呢 一个可以把方法当做变量来赋值传值的数据类型。