委托

引子

delegate：代表，授权，翻译为“委托”，即用对象代表方法成员或对象被授权执行方法成员。看下面一小段代码：

int Max(int x,int y)
{
    return x>y?x:y;
}
int Min(int x,int y)
{
    return x<y?x:y;
}

上面两个函数的共同特点：具有相同的返回值和参数列表。在C++里，我们使用函数指针来指代（被授权，代表）这两个函数。实际上，我们可以用函数指针指向任意一个具有相同返回值和参数列表的函数（静态方法或实例的方法成员）。

//定义一个函数指针，并声明该指针可以指向的函数的返回值为int类型，参数列表中包括两个int类型的参数
int (*p)(int,int);
//让指针p指向Max函数
p=max;
//利用指针调用Max
c=(*p)(5,6);

在C#里没有提供函数指针，取而代之的是委托（delegate）；利用委托，我们可以像使用函数指针一样在程序运行时动态指向具备相同签名（具有相同参数类型、参数个数以及相同类型返回值）的方法。

委托的定义

之前我们在引出委托时已经简单的介绍了委托的本质：函数指针。说的通俗一些，委托就是能够让方法作为变量来传递。我个人喜欢下面这个定义：

委托是一种类型安全的函数回调机制，它不仅能够调用实例方法，也能调用静态方法，并且具备按顺序执行多个方法的能力。

也就是说，委托可以在程序运行时调用不同方法函数，只要这个方法签名和委托签名保持一致。与函数指针不同的是，委托是类型安全的。所谓类型安全，是指在编译时编译器会检测委托对象的签名是否委托声明一致。看下面一小段简单的代码感受委托的含义：

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

namespace DelegateSamples
{
    //声明一个委托，参数为string，无返回值
    delegate void DelSamples(string msg);
    class Program
    {
        static void Main(string[] args)
        {
            DelSamples delSample = new Program().SpeakChinese; //调用实例方法
            delSample += SpeakEnglish; //调用静态方法
            delSample("KoalaStudio");
            Console.ReadKey();
        }

        private void SpeakChinese(string msg)
        {
            Console.WriteLine("你好，我是{0}",msg);
        }

        private static void SpeakEnglish(string msg)
        {
            Console.WriteLine("Hello,I'm {0}",msg);
        }
    }
}

输出结果：

委托的声明

简单委托

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

namespace DelegateSamples
{
    //声明一个委托，参数为string，无返回值
    delegate void DelSamples(string msg);
    class Program
    {
        static void Main(string[] args)
        {
          //使用new关键字
          DelSamples delSample = new DelSamples(new Program().SpeakChinese);
          delSample("Koala工作室");

          //不使用new，自动推断委托类型
          DelSamples delSample2 = SpeakEnglish;
          delSample2("KoalaStudio");

          //利用Lambda表达式
          DelSamples delSample3 = (string msg) => SpeakEnglish(msg);
          delSample3("KoalaStudio");

          Console.ReadKey();
        }

        private void SpeakChinese(string msg)
        {
            Console.WriteLine("你好，我是{0}",msg);
        }

        private static void SpeakEnglish(string msg)
        {
            Console.WriteLine("Hello,I'm {0}",msg);
        }
    }
}

匿名委托

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

namespace DelegateSamples
{
    //声明一个委托，参数为string，无返回值
    delegate void DelSamples(string msg);
    class Program
    {
        static void Main(string[] args)
        {
          //匿名委托
          DelSamples delSample4 = delegate(string msg)
          {
              Console.WriteLine("你好，我是{0}", msg);
          };
          delSample4("KoalaStudio");

          //利用Lambda表达式实现匿名委托
          DelSamples delSample5 = (string msg) => {
             Console.WriteLine("你好，我是{0}", msg);
          };
          delSample5("KoalaStudio");

          Console.ReadKey();
        }

        private void SpeakChinese(string msg)
        {
            Console.WriteLine("你好，我是{0}",msg);
        }

        private static void SpeakEnglish(string msg)
        {
            Console.WriteLine("Hello,I'm {0}",msg);
        }
    }
}

匿名委托的写法更加优雅，但是需要注意两点：1、在函数内部不能使用跳转语句跳出函数外部；2、不能使用ref和out等关键字

多播委托

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

namespace DelegateSamples
{
    //声明一个委托，参数为string，无返回值
    delegate void DelSamples(string msg);
    class Program
    {
        static void Main(string[] args)
        {
            //多播委托可以带返回值，但是只有最后一个方法的返回值会被返回。
            DelSamples delSample6 = new Program().SpeakChinese;
            delSample6 += SpeakEnglish;
            delSample6("KoalaStudio");

            Console.ReadKey();
        }

        private void SpeakChinese(string msg)
        {
            Console.WriteLine("你好，我是{0}",msg);
        }

        private static void SpeakEnglish(string msg)
        {
            Console.WriteLine("Hello,I'm {0}",msg);
        }
    }
}

多播委托可以连续执行函数,但是如果函数有返回值,那只有最后一个函数的返回值会被正确返回.

泛型委托

泛型委托和一般的委托用法类似，只是习惯了传统委托的使用后在写法上看着有些别扭。泛型委托可能在运行时确定委托的类型，提高了委托的通用性，这和泛型类的意义是一样的。这里不再介绍泛型的概念，如果你对泛型还不熟悉，园子里有很多优秀的文章已经详细介绍了相关内容。泛型委托包括Action、Func和 Predicate三种委托。

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

namespace DelegateSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Action<T>:封装只有一个参数（类型为T），不包括返回值的签名函数，它包括以下几种情况：
             * Action<T>、Action<T1,T2>、Action<T1,T2,T3>、Action<T1,T2,T3,T4>
             * 声明：
             * delegate void Action();
             * delegate void Action<T1>(T1 arg1);
             * delegate void Action<T1,T2>(T1 arg1,T2 arg2);
             * delegate void Action<T1,T2,T3>(T1 arg1,T2 arg2,T3 arg3);
             * delegate void Action<T1,T2,T3,T4>(T1 arg1,T2 arg2,T3 arg3,T4 arg4);
             */
            Action<string> action = SpeakEnglish;
            action("KoalaStudio");

            Action<string, string> action2 = SpeakTwoLanguage;
            action2("KoalaStudio","Koala工作室");
            Console.ReadKey();
        }

        private void SpeakChinese(string msg)
        {
            Console.WriteLine("你好，我是{0}",msg);
        }

        private static void SpeakEnglish(string msg)
        {
            Console.WriteLine("Hello,I'm {0}",msg);
        }

        private static void SpeakTwoLanguage(string msg1, string msg2)
        {
            Console.WriteLine("你好，我是{0}",msg1);
            Console.WriteLine("Hello,I'm {0}",msg2);
        }
    }
}

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

namespace DelegateSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Func<T,TResult>:封装一个具有参数（类型为T），返回TResult类型值的签名函数，它包括以下几种情况：
             * Func<T,TResult>、Func<T1,T2,TResult>、Func<T1,T2,T3,TResult>、Func<T1,T2,T3,T4,TResult>
             * 声明：
             * ……略去
             */
            Func<string,string/*这是返回值类型*/> func = SpeakEnglish;
            func("KoalaStudio");

            Func<string, string, string/*这是返回值类型*/> func2 = SpeakTwoLanguage;
            func2("KoalaStudio","Koala工作室");
            Console.ReadKey();
        }

        private static string SpeakEnglish(string msg)
        {
            return string.Format("Hello,I'm {0}", msg);
        }

        private static string SpeakTwoLanguage(string msg1, string msg2)
        {
            Console.WriteLine("你好，我是{0}",msg1);
            Console.WriteLine("Hello,I'm {0}",msg2);
            return string.Format("你好，我是{0};Hello,I'm {1}", msg1,msg2);
        }
    }
}

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

namespace DelegateSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            /* bool Predicate<T>:表示定义一组条件并确定指定对象是否符合这些条件的方法。
             * 通常，此类委托由Array和List类的几种方法使用，用于在集合中搜索元素。
             * delegate bool Predicate<T>(T obj),如果obj符合此委托表示的方法中定义的条件，则返回true，否则返回false
             */

            List<string> listString = new List<string>()
            {
                "a","abc","koala","xyz","take"
            };

            //List对象的FindAll定义：public List<T> FindAll(Predicate<T> match)；
            //match 类型：System.Predicate<T> 委托，用于定义要搜索的元素应满足的条件。
            //返回值
            //类型：System.Collections.Generic.List<T>
            //如果找到，则为一个 List<T>，其中包含与指定谓词所定义的条件相匹配的所有元素；否则为一个空 List<T>。
            Predicate<String> match = delegate(string word)
            {
               if (word.Length > 4)
               {
                   return true;
               }
               return false;
            };

            List<string> result = listString.FindAll(match);
        }
    }
}

看到这里相信大家都已经感觉出来了，委托的申明和使用和类非常相似。没错，委托本质上就是一个类。实际上，我们用delegate关键字声明的所有委托都继承自System.MulticastDelegate类，这个类又继承自System.Delegate类，而System.Delegate类则继承自System.Object。尽管如此，我们并不能直接声明一个继承自System.MulticastDelegate类的委托，委托必须用 delegate关键字声明。在我们声明委托时，编译器为我们完成了很多复杂的工作，有兴趣的朋友可以查阅相关资料。不过，即使不清楚编译器为我们干了什么也没有关系，只要知道在我们调用委托时，编译器自动为委托创建了BeginInvoke、EndInvoke和Invoke三个方法。BeginInvoke和EndInvoke方法用来实现异步委托调用，后面我们再详细介绍。

DelSamples delSample2 = SpeakEnglish;
delSample2("KoalaStudio");
//其实是调用编译器生成的Invoke方法
delSample2.Invoke("KoalaStudio");

写到这儿，其实已经把委托的基本概念介绍完了。接下去的内容会稍微复杂一些，刚刚接触委托的朋友可以跳过这部分，直接阅读委托与事件部分。

协变与逆变

MSDN的解释：从Visual Studio2008开始.NET引入了变体支持，用于委托中匹配方法签名和委托类型。这意味着，我们不仅可以为委托指派具有匹配签名的方法，而且可以指派这样的方法：它们返回与委托类型指定的派生类型相比，派生程度更大的类型（协变），或者接受相比之下，派生程度更小的类型的参数（逆变）。相当拗口，对不对？不知道它想说明什么。稍微休息一下，忘记之前那长串的描述。我们来想一个情形：面向对象的一个典型应用就是继承和多态。假如我们定义了一个委托，它返回的类型是一个基类对象。如果有个方法，它的参数签名符合我们定义的委托参数签名，但是返回的是继承该基类的子类对象，那么这个方法是否能够使用该委托？又比如，我们定义了一个委托，它具有指定的参数签名。如果有个方法，它的参数是委托签名中的方法参数的基类（委托方法签名中的参数派生自调用方法的参数），那么这个方法是否能够使用该委托？答案是可以的！这也就是MSDN想说的：协变就是委托的类型返回值是它所指向函数（即调用的方法）的返回值的基类；逆变就是委托的类型参数是它所指向函数的参数的派生类。协变允许方法具有的派生返回类型比委托中定义的更多。逆变允许方法具有的派生参数类型比委托类型中的更少。MSDN上提供的一个协变的例子：

class Mammals{}
class Dogs : Mammals{}

class Program
{
    // 定义一个委托，返回基类.
    public delegate Mammals HandlerMethod();

    public static Mammals MammalsHandler()
    {
        return null;
    }

    public static Dogs DogsHandler()
    {
        return null;
    }

    static void Test()
    {
        HandlerMethod handlerMammals = MammalsHandler;

        // 被允许.
        HandlerMethod handlerDogs = DogsHandler;
    }
}

再看个逆变的例子：

// Event hander接受一个EventArgs类型的参数.
private void MultiHandler(object sender, System.EventArgs e)
{
    label1.Text = System.DateTime.Now.ToString();
}

public Form1()
{
    InitializeComponent();

    // KeyDown期望接受的是KeyEventArgs对象，但是我们给的是EventArgs对象
    this.button1.KeyDown += this.MultiHandler;

    this.button1.MouseClick += this.MultiHandler;

}

协变和逆变先介绍基本的应用，其它还包括泛型委托的协变和逆变，有兴趣的朋友可以参考MSDN里的例子，这里不再赘述。

异步委托

既然委托可以在运行时调用方法函数，如果调用的方法非常复杂耗时，主线程是不是会被阻塞以等待方法执行？我们看一段代码：

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

namespace DelegateSamples
{
    public delegate void delSample ();
    class Program
    {
        static void Main(string[] args)
        {
            delSample _sample = DoTask;
            _sample();
            Console.WriteLine("执行另一项工作。");
            Console.ReadKey();
        }

        public static void DoTask()
        {
            Console.WriteLine("开始执行复杂工作。");
            //线程阻塞5s，模拟进行复杂的工作。
            Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("工作执行完毕。");
        }
    }
}

从下面的输出结果我们看到，委托调用的是主线程，因此复杂的方法函数会导致主线程阻塞，影响用户体验。那有没有办法可以改变呢？有！异步委托。

异步委托会从线程池中开辟一个新的线程用来调用方法，我们改动一下上面的代码，开启异步委托：

namespace DelegateSamples
{
    public delegate void delSample ();
    class Program
    {
        static void Main(string[] args)
        {
            delSample _sample = DoTask;
            _sample.BeginInvoke(null, null);
            Console.WriteLine("执行另一项工作。");
            Console.ReadKey();
        }

        public static void DoTask()
        {
            Console.WriteLine("开始执行复杂工作。");
            //线程阻塞5s，模拟进行复杂的工作。
            Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("工作执行完毕。");
        }
    }
}

看一下返回结果：

好像和我们预想的不太一样，主线程并没有等待委托的执行，而是继续执行下面的操作并退出。这是什么原因？还是和线程有关。默认线程池中的线程都是后台线程，主线程不会等待后台线程的执行，仿佛它根本不存在。那有办法解决这个问题吗？能不能让主线程等待委托线程执行完毕在退出？我们再看一下MSDN给出的解释：BeingInvoke方法启动异步委托，它具有和异步执行的方法相同的参数，同时还有两个可选参数。第一个参数是AsyncCallBack委托，该委托引用在异步调用完成时要调用的方法（即回调函数）；第二个参数是一个用户定义的对象，可以将信息传入回调函数。BeginInvoke立即返回而不等待异步调用完成（这就解释了上面的原因），但是会返回一个用于监控异步调用进度的IAsyncResult。EndInvoke方法检索异步调用的结果。在调用 BeginInvoke 之后随时可以调用该方法。如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成。我们改一下上面的代码：

namespace DelegateSamples
{
    public delegate void delSample ();
    class Program
    {
        static void Main(string[] args)
        {
            delSample _sample = DoTask;
            IAsyncResult result = _sample.BeginInvoke(null, null);
            while (result.IsCompleted)
            {
                //可以监控异步方法执行是否完成
                //do task
            }
            _sample.EndInvoke(result);
            Console.WriteLine("执行另一项工作。");
            Console.ReadKey();
        }

        public static void DoTask()
        {
            Console.WriteLine("开始执行复杂工作。");
            //线程阻塞5s，模拟进行复杂的工作。
            Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("工作执行完毕。");
        }
    }
}

从输出结果看，委托线程确实阻塞了主线程，但是这依然会影响用户体验。我们希望的流程是：主线程调用委托线程后继续执行后面的逻辑业务，等逻辑业务完成后等待委托线程的返回。我们利用 WaitHandle等待异步调用来解决这个问题，异步调用完成时会发出WaitHandle信号，我们可以通过调用WaitOne方法等待该信号。

namespace DelegateSamples
{
    public delegate void delSample ();
    class Program
    {
        static void Main(string[] args)
        {
            delSample _sample = DoTask;
            IAsyncResult result = _sample.BeginInvoke(null, null);
            //等待1s，执行主线程
            result.AsyncWaitHandle.WaitOne(1,false);

//_sample();
            //_sample.EndInvoke(result);
            Console.WriteLine("执行另一项工作。");
            _sample.EndInvoke(result);
            Console.ReadKey();
        }

        public static void DoTask()
        {
            Console.WriteLine("开始执行复杂工作。");
            //线程阻塞5s，模拟进行复杂的工作。
              Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("工作执行完毕。");
        }
    }
}

再看一种回调模式

namespace DelegateSamples
{
    public delegate void delSample ();
    class Program
    {
        static void Main(string[] args)
        {
            delSample _sample = DoTask;
            _sample.BeginInvoke(
                delegate(IAsyncResult ar)
                { _sample.EndInvoke(ar); },null
            );
            Console.WriteLine("执行另一项工作。");
            Console.ReadKey();
        }

        public static void DoTask()
        {
            Console.WriteLine("开始执行复杂工作。");
            //线程阻塞5s，模拟进行复杂的工作。
            Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("工作执行完毕。");
        }
    }
}

回调模式是在BeginInvoke后立刻调用回调函数，这个回调函数是在 ThreadPool线程上进行的，因此主线程将继续执行。ThreadPool线程是后台线程，这些线程不会在主线程结束后保持应用程序的运行，因此主线程必须休眠足够长的时间以便回调完成。我们也可以在主线程完成操作后调用IsCompleted属性判断委托函数是否完成。

委托与事件

既然说了委托，自然离不开事件。在这里我不打算详细阐述事件机制及其相关的内容，后面我会再整理一篇有关事件的文章。我打算从委托出发，看看事件是怎么和委托扯上关系的。先看一段代码：

namespace DelegateSamples
{
    public class Program
    {
        static void Main(string[] args)
        {
            Publish publish = new Publish();
            Subscribe subscribe = new Subscribe();
            publish.delEventHandler += subscribe.OnLeaveMessage;
            publish.OnFire("我触发了委托！");
            //调用委托
            publish.delEventHandler("我触发了委托！");
            Console.ReadKey();
        }

    }
    //定义委托
    public delegate void FireEventHandler(string msg);
    public class Publish
    {
        public FireEventHandler delEventHandler;

        public void OnFire(string msg)
        {
            if (delEventHandler != null)
            {
                delEventHandler(msg);
            }
        }

    }

    public class Subscribe
    {
        public Subscribe(){}

        public void OnLeaveMessage(string msg)
        {
            Console.WriteLine(msg);
        }
    }
}

这里我们发现，如果要使用委托变量，那么在类的内部委托变量必须是public，这就显得不安全。我只希望外部通过Publish.OnFire()来执行委托，但是外部仍然可以直接调用委托。于是，我们换一个写法，再看代码：

namespace DelegateSamples
{
    public class Program
    {
        static void Main(string[] args)
        {
            Publish publish = new Publish();
            Subscribe subscribe = new Subscribe();
            publish.delEventHandler += subscribe.OnLeaveMessage;
            publish.OnFire("我触发了委托！");
            //调用委托
            publish.delEventHandler("我触发了委托！");
            Console.ReadKey();
        }

    }
    //定义委托
    public delegate void FireEventHandler(string msg);
    public class Publish
    {
        //public FireEventHandler delEventHandler;
        //不使用委托关键字delegate，采用event关键字
        public event FireEventHandler delEventHandler;
        public void OnFire(string msg)
        {
            if (delEventHandler != null)
            {
                delEventHandler(msg);
            }
        }

    }

    public class Subscribe
    {
        public Subscribe(){}

        public void OnLeaveMessage(string msg)
        {
            Console.WriteLine(msg);
        }
    }
}

publish.delEventHandler("我触发了委托！")，编译无法通过，这意味着外部不能直接调用委托变量，尽管他的属性还是 public。因为加了event关键字，本质上是生成了私有的委托变量，减少了外部对类内部变量的修改权利。说到这里，我们再来看一下事件和委托的关系。在CLR综合那个事件模型是建立在委托机制上的，这就是他们之间的联系。委托是对方法的抽象，它将方法的调用与实现分离，方法的调用者（即委托的执行者）不知道方法内部的实现，而方法的实现者也不知道方法什么时候会被调用。正是因为委托具有这样的特性，才使得它理所当然的用来实现事件机制。因为事件被触发后执行什么操作，是由触发者决定的，而事件拥有者只知道什么情况下会触发事件，但不知道事件的具体实现。

最后，我们看一下事件的定义。事件用event关键字定义，其类型是一个委托类型，这体现了事件是通过委托来实现的。上面的代码已经展示了最基本的事件定义方式，即：自定义一个委托，然后再申明一个event事件。在.NET3.5开始，由于支持泛型，定义事件时可以不需要再自定义委托，统一采用 System.EventHandler<TEventArgs>委托，如何改造上面代码，请大家自行修改。

摘自：http://www.cnblogs.com/laoyu/archive/2013/01/13/2859000.html

posted @ 2014-01-09 10:42 蚂蚁拉车阅读(401) 评论(0) 编辑收藏举报

刷新页面返回顶部

狂奔的蜗牛

委托

公告