码迷,mamicode.com
首页 > Windows程序 > 详细

C#3.0新特性——委托详解

时间:2014-12-02 19:12:34      阅读:331      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   io   ar   color   os   使用   sp   

前言

 

委托的定义

委托的本质:函数指针。让方法作为变量一样传递。

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

也就是说,委托可以在程序运行时调用不同方法函数,只要这个方法签名和委托签名保持一致。与函数指针不同的是,委托是类型安全的。所谓类型安全,是指在编译时编译器会检测委托对象的签名是否委托声明一致。

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<T>

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);
        }
    }
}

Func<T,TResult>:

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);
        }
    }
}

Predicate<T>

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("工作执行完毕。");
        }
    }
}

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

bubuko.com,布布扣

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

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("工作执行完毕。");
        }
    }
}

看一下返回结果:

bubuko.com,布布扣

    好像和我们预想的不太一样,主线程并没有等待委托的执行,而是继续执行下面的操作并退出。这是什么原因?还是和线程有关。默认线程池中的线程都是后台线程,主线程不会等待后台线程的执行,仿佛它根本不存在。那有办法解决这个问题吗?能不能让主线程等待委托线程执行完毕在退出?我们再看一下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("工作执行完毕。");
        }
    }
}

bubuko.com,布布扣

从输出结果看,委托线程确实阻塞了主线程,但是这依然会影响用户体验。我们希望的流程是:主线程调用委托线程后继续执行后面的逻辑业务,等逻辑业务完成后等待委托线程的返回。我们利用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>委托,如何改造上面代码,请大家自行修改。

C#3.0新特性——委托详解

标签:style   blog   http   io   ar   color   os   使用   sp   

原文地址:http://www.cnblogs.com/cmhunter/p/4138145.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!