[C# 基础知识系列]专题三:如何用委托包装多个方法——委托链 (转载)

引言:

 上一专题介绍了下编译器是如何来翻译委托的,从中间语言的角度去看委托,希望可以帮助大家进一步的理解委托,然而之前的介绍都是委托只是封装一个方法,那委托能不能封装多个方法呢?因为生活中经常会听到,我代表大家的意见等这样的说话,既然委托也是一个代表,那他如果只能代表一个人,那他的魅力就不是很大了吧,所以我们就会委托能不能代表多个方法的? 答案是可以的,这就是本专题要讲的内容——委托链,委托链也是一个委托,只是因为它是把多个委托链在一起,所以我们就以委托链来这么称呼它的

 

一、到底什么是委托链

我们平常实例化委托对象时都是绑定一个方法的, 前一个专题介绍的委托也是包装了一个方法的, 用前面的例子就是委派律师的只有一个人,也就是当事人只有一个的,但是现实生活中显然不是这样的,在官司的时候律师可以同时接多个案子,也是接收多个当时人的委派,这样,该律师就与多个当事人绑定在一起了, 需要了解多个当事人的案件情况的。其实这就是生活中的委托链,此时这位律师不仅仅是一个人的代表律师了,而是多个当事人的律师。生活中的委托链和C#中的委托链很类似的,现在就说说C#中的委托链到底是个什么的?

首先委托链就是一个委托,所以大家不要看到委托链感觉又是什么C#中的新特性的,然而要把多个委托链在一起,就必须存储多个委托的引用,那委托链对象是在哪里存储多个委托的引用的呢?还记得我们上一专题中,我们介绍的委托类型有三个非公共字段的吗?这三个字段是——_target,methodPtr 和_invocationList,至于这三个字段具体代表什么大家可以查看我的上一专题的文章,然而_invocationList 字段正是存储多个委托引用的地方的

为了更好的解释_invocationList是如何来存储委托引用的,下面先看一个委托链的例子和运行结果,然后再分析原因:

复制代码
using System;

namespace DelegateTest

{
    public class Program
    {
        // 声明一个委托类型,它的实例引用一个方法
        // 该方法回去一个int 参数,返回void类型
        public delegate void DelegateTest(int parm);

        public static void Main(string[] args)
        {
            // 用静态方法来实例化委托
            DelegateTest dtstatic = new DelegateTest(Program.method1);

            // 用实例方法来实例化委托
            DelegateTest dtinstance = new DelegateTest(new Program().method2);
            
            // 隐式调用委托
            dtstatic(1);

            // 显式调用Invoke方法来调用委托
            dtinstance.Invoke(1);

            // 隐式调用委托
            dtstatic(2);

            // 显式调用Invoke方法来调用委托
            dtinstance.Invoke(2);
            Console.Read();
        }
        private static void method1(int parm)
        {
            Console.WriteLine("调用的是静态方法,参数值为:" + parm);
        }

        private void method2(int parm)
        {
            Console.WriteLine("调用的是实例方法,参数值为:" + parm);
        }
    }

}
复制代码

运行结果:

下面就来分析下为什么会出现这样的结果的:

一开始我们实例化了两个委托变量,如下代码:

 // 用静态方法来实例化委托
            DelegateTest dtstatic = new DelegateTest(Program.method1);

            // 用实例方法来实例化委托
            DelegateTest dtinstance = new DelegateTest(new Program().method2);

委托变量dtstatic和dtinstance引用的委托对象的初始状态如下图:

然后我们定义了一个委托类型的引用变量delegatechain,刚开始它没有任何委托对象,是一个空引用,当我们执行下面的一行代码时,

delegatechain = (DelegateTest)Delegate.Combine(delegatechain, dtstatic);

Combine方法发现试图合并的是null和dtstatic,在内部,Combine直接返回dtstatic中的对象,此时delegatechain和dtstatic变量引用的都是同一个委托对象,如下图所示:

为了演示委托链,我们通过代码在再添加一个委托,此时就再调用了Combine方法,代码如下:

 delegatechain = (DelegateTest)Delegate.Combine(delegatechain, dtinstance);

这时候,Combine方法发现delegatechain已经引用了一个委托对象了(此时已经引用了destatic引用的委托对象了),所以Combine构造一个新的委托对象(这一点很想String.Concat,我们简单的使用是通过+操作符把两个字符串连接起来,关于字符串的讨论大家可以参考我博客中的这篇文章http://www.cnblogs.com/zhili/archive/2012/06/25/String_StringBuilder.html),这个新的委托对象会对它的私有字段_target 和_methodPtr字段进行初始化,然后此时_invocationList字段初始化为引用了一个委托对象的数组,这个数组的第一个元素(下标为0)就是被初始化为引用包装了method1方法的委托,数组的二个元素被初始化为引用包装了method2方法的委托(也就是dtinstance引用的委托对象),最后delegaechain被设为引用新建的这个委托对象,下面是一个图,可以帮助大家理解委托链(也叫多播委托):

同样的道理,如果是添加第三个委托给委托链,过程也是和上面一样的, 此时又会新建一个委托对象,此时_invocationList字段会初始化为引用一个保存这三个委托对象数组,然而有人会问了——对于已经引用了委托对象的委托类型变量调用Combine方法后会创建一个新的委托对象,然后对新的这个委托对象的三个字段进行重新初始化话,最后把之前的委托类型变量引用新创建的委托对象(这里就帮大家总结下委托链的创建过程),那之前的委托对象怎么办呢? 相信大部分人会有这个疑问的,这点和字符串的Concat方法很像,之前的委托对象和——invocationList字段引用的数组会被垃圾回收掉(正是因为这样,委托和字符串String一样是不可变的)。

注意:我们还可以调用Delegate的Remove方法从链中删除委托,如调用下面代码时:

 delegatechain =(DelegateTest)Delegate.Remove(delegatechain,new DelegateTest(method1));

Remove方法被调用时,它会扫描delegateChain(第一个参数)所引用的委托对象内部维护的委托数组(如果对于委托数组为空的情况下调用Remove方法将不会有任何作用,就是不会删除任何委托引用,这里主要是说明扫描是从委托数组里进行扫描),如果找到delegateChain引用的委托对象的_target和_methodPtr字段

和第二个参数(新创建的委托)中的字段匹配的委托,如果删除之后数组中只剩下一个数据项时,就返回那个数据项(而不会去新建一个委托对象再初始化的,此时的_invocationList为null,而不是保存一个委托对象引用的数组了,具体可以Remove一个后调试看看的),如果此时数组中还剩余多个数据项,就新建一个委托对象——其中创建并初始化_invocationList数组(此时的数组引用的委托对象已经少了一个了,因为用Remove方法删除了),并且,每次Remove方法调用只能从链中删除一个委托,而不会删除有匹配的_target和_methodPtr字段的所有委托(这个大家可以调试看看的)

 

二、如何对委托链中的委托调用进行控制

通过上面相信大家可以理解如何创建一个委托链对象的,但是从运行结果中还可以看出,每次调用委托链时,委托链包装的每个方法都会顺序被执行,如果委托链中被调用的委托抛出一个异常,这样链中的后续所有对象都不能被调用,并且如果委托的前面具有一个非void的返回类型,则只有最后一个返回值会被保留,其他所有回调方法的返回值都会被舍弃,这就意味着其他所有操作的返回值都永远看不到的吗? 事实却不是这样的,我们可以通过调用Delegate.GetInvocationList方法来显式调用链中的每一个委托,同时可以添加一些自己的定义输出。

GetInvocationList方法返回一个由Delegate引用构成的数组,其中每一个数组都指向链中的一个委托对象。在内部,GetInvocationList创建并初始化一个数组,让数据的每一个元素都引用链中的一个委托,然后返回对该数组的一个引用。如果_invocatinList字段为null,返回的数组只有一个元素,该元素就是委托实例本身。下面就通过一个程序来演示下的:

复制代码
namespace DelegateChainDemo
{
    class Program
    {
        // 声明一个委托类型,它的实例引用一个方法
        // 该方法回去一个int 参数,返回void类型
        public delegate string DelegateTest();

        static void Main(string[] args)
        {
            // 用静态方法来实例化委托
            DelegateTest dtstatic = new DelegateTest(Program.method1);

            // 用实例方法来实例化委托
            DelegateTest dtinstance = new DelegateTest(new Program().method2);
            DelegateTest dtinstance2 = new DelegateTest(new Program().method3);
            // 定义一个委托链对象,一开始初始化为null,就是不代表任何方法(我就是我,我不代表任何人)
            DelegateTest delegatechain = null;
            delegatechain += dtstatic;
            delegatechain += dtinstance;
            delegatechain += dtinstance2;

            ////delegatechain =(DelegateTest)Delegate.Remove(delegatechain,new DelegateTest(method1));
            ////delegatechain = (DelegateTest)Delegate.Remove(delegatechain, new DelegateTest(new Program().method2));
            Console.WriteLine(Test(delegatechain));
            Console.Read();
        }

        private static string method1()
        {
            return "这是静态方法1";
        }

        private string method2()
        {
            throw new Exception("抛出了一个异常");
        }

        private string method3()
        {
            return "这是实例方法3";
        }
        // 测试调用委托的方法
        private static string Test(DelegateTest chain)
        {
            if (chain == null)
            {
                return null;
            }

            // 用这个变量来保存输出的字符串
            StringBuilder returnstring = new StringBuilder();

            // 获取一个委托数组,其中每个元素都引用链中的委托
            Delegate[] delegatearray=chain.GetInvocationList();

            // 遍历数组中的每个委托
            foreach (DelegateTest t in delegatearray)
            {
                try
                {
                    //调用委托获得返回值
                    returnstring.Append(t() + Environment.NewLine);
                }
                catch (Exception e)
                {
                    returnstring.AppendFormat("异常从 {0} 方法中抛出, 异常信息为:{1}{2}", t.Method.Name, e.Message, Environment.NewLine);
                }
            }

            // 把结果返回给调用者
            return returnstring.ToString();
        }
    }
}
复制代码

运行结果截图:

从运行结果可以看出,此时我们可以获得每一个回调方法的返回值,并且可以加入一些自定义的返回值的(程序中加入了换行字符串),这样就可以对委托链中的每个委托对象进行控制了,即使其中一个抛出异常,此时我们也可以进行捕获,而不会导致后续的委托对象不能被调用的问题。

 

三、总结下

本专题主要介绍如何创建一个委托链以及对于创建一个委托链的过程进行了详细的分享,第二部分主要先指出了委托了一些局限性,然后通过调用GetInvocationList方法来返回一个委托数组,这样就可以通过遍历委托数组中的每个委托来通知委托的调用过程,这样就可以对委托链的调用进行更多的控制的。到此本专题也就介绍完了,通过这三个专题对委托的介绍,相信大家会对委托有一个更深的理解,然后为什么要写三个专题来详细介绍委托的呢? 主要是后面要介绍的事件,Lambda表达式,Linq方面的内容都是和委托有关系的,所以更好的理解委托将是后面特性的一个基础,希望这些对大家有帮助,我将在下一个专题里面介绍事件。

猜你喜欢

转载自www.cnblogs.com/neooo/p/10374007.html
0条评论
添加一条新回复