理解委托

委托是一种特殊的引用类型，它将方法作为特殊的对象封装起来，从而将方法作为变量或是参数进行传递。

委托在使用过程中的一般步骤：类型定义、对象创建和方法绑定，方法调用。

所谓的委托就是我委托你去买火车票，你有自己去买火车票的方法，我要的最终结果是你把火车票买了。在这过程中你就是一个委托。其中这个委托要进行四个步骤：类型定义（让别人帮你买火车票这一事件）对象创建（具体委托谁去买和那人说一声），方法绑定（告诉你委托的人要买什么样的火车票），方法的调用（委托的人买到了你要的火车票）。

在使用委托的时候首先是在程序的开始声明一个委托，在使用这个委托的时候要实例化一个委托（使用 的具体的委托就是一个对象），委托的本质是类，在用new的表达式中要封装的就是方法名，而不包括方法的参数和返回值（如果是非静态的方法还要指出方法所属的对象）。

委托是一种引用方法类型，一旦委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的‘类’，委托的实例将代表一个具体的函数。

<span style="font-family: SimSun; font-size: 13px;">简单示例：
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
namespace 委托的方法调用 
{ 
    //定义委托对象 
    delegate void DualFunction(double num1,doublenum2); 
    class Program 
    { 
                static void Main(string[] args) 
                { 
                        //实例化一个委托对象 
                        DualFunction fun1; 
                        double a = 2.5, b = 2; 
                        Console.Write("请选择函数(加0减1乘2除3):"); 
                        int i = int.Parse(Console.ReadLine()); 
                        if (i == 1) 
                        fun1 = new DualFunction(Sub); 
                        else if (i == 2) 
                        fun1 = new DualFunction(Mul); 
                        else if (i == 3) 
                        fun1 = new DualFunction(Div); 
                        else 
                        fun1 = new DualFunction(Add); 
                        fun1(a, b); 
                        Console.Read(); 
                } 
                        //定义静态函数。 
                        static void Add(double num1, double num2) 
                        { 
                           Console.WriteLine("{0}+{1}={2}",num1,num2, num1  +num2); 
                        } 
                        static void Sub(double num1, double num2) 
                        { 
                           Console.WriteLine("{0}-{1}={2}",num1,num2,num1 -num2); 
                        } 
                        static void Mul(double num1, double num2 ) 
                        { 
                           Console.WriteLine("{0}* {1}={2}",num1,num2,num1 *num2); 
                        } 
                        static void Div(double num1, double num2) 
                        { 
                           Console.WriteLine("{0}/{1}={2}",num1,num2,num1 /num2); 
                        } 
     
    } 
}
</span>

例如大话设计中委托的使用。

在大话设计模式中，观察者模式的缺点是‘抽象的通知者’还是依赖于‘抽象的观察者’。为了更好的实现通知者和观察者的分离，完全由客户端来决定通知谁，在这其中就是用了委托来进一步的优化。

抽象观察者和抽象通知者的依赖。

<span style="font-family: SimSun; font-size: 13px;">//通知者接口
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }
    //观察者接口
    abstract class Observer
    {
        protected string name;
        protected Subject sub;

        public Observer(string nmae, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public abstract void Update();
}
</span>

不难看出观察者和通知者是相互依赖的关系。为了使他们以及实现通知者接口和观察者抽象类的子类独立性强，实现有客户端来操作，这里面就是用委托来实现的通知者和观察者的分离。

去掉抽象观察者，保留抽象通知者，同时去掉增加和减少观察者的方法，去掉与观察者的依赖关系，而是在具体的观察者类中声明了委托事件，在客户端实现委托方法的传递。

<span style="font-family: SimSun; font-size: 13px;">//具体的观察类中声明的委托。
    class Boss : Subject
    {
        //声明以事件Update，类型为委托EventHander,委托的变量名为Update
        public event EventHandler Update;
        private string action;
        public void Notify()
        {

            Update();
        }
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
}
</span>

客户端中使用的委托，搭载委托对象。

<span style="font-family: SimSun; font-size: 13px;">huhansan .Update + =new EventHandler (tongshi1.CloseStockMarket);
huhansan .Update + =new EventHandler (tongshi2.CloseNBADirectSeeding);
</span>

一个委托可以搭载多个方法，所有方法被依次唤起。并且可以使得委托对想所搭载的方法并不需要属于同一个类。

委托前提：委托对象所搭载的所有方法必须具有相同的圆形和形式，也就是拥有相同的参数列表和返回值类型。（在这里面Update方法和两个观察类中的CloseStockMarket和CloseNBADirectSeeding的方法都是没有参数的。）