C​#​ ​D​e​l​e​g​a​t​e (一)

[转序：这是一篇古老的文章。但毫无疑问，Lippman对delegate的阐述是精辟的。]

如果你想拿C# 与其它“C家族”的语言做比较，C#正有个不同寻常的特性，其在C++ 或者Java 里没有真正意义上的对应之物。

--------------------------------------------------------------------------------

C# 是一个颇具争议的新兴语言，由Microsoft 开发创造，以作为其Visual Studio.NET 的基石。C#结合了源自C++ 和Java 的许多特性。Java社群对C# 主要的批评在于，其声称C# 只是一个蹩脚的Java 克隆版本 ——与其说它是语言创新的成果，倒不如说是一桩诉讼的结果。而在C++ 社群里，主要的批评（也同时针对Java）是，C#只不过是另一个泛吹滥捧的私有语言（yet another over-hyped proprietary language）。

本文意在展示一种C# 的语言特性，而在C++ 或Java 中都没有直接支持类似的特性。这就是C# 的delegate 型别，其运作近似于一种指向成员函数的指针。我认为，C# delegate 型别是经过深思熟虑的创新型语言特性，C++程序员（无论其对C# 或者Microsoft 有何想法）应该会对这个特性产生特殊的兴趣。

为了激发讨论，我将围绕一个testHarness class 的设计来进行阐述。这个testHarness class 能够让任何类别对static 或non-static 的class methods 进行注册，以便后续予以执行。Delegate型别正是实现testHarness class 的核心。

C# 的 Delegate Type

Delegate 是一种函数指针，但与普通的函数指针相比，区别主要有三：

1) 一个 delegate object 一次可以搭载多个方法（methods），而不是一次一个。当我们唤起一个搭载了多个方法（methods）的delegate，所有方法以其“被搭载到delegate object 的顺序”被依次唤起——稍候我们就来看看如何这样做。

2) 一个 delegate object 所搭载的方法（methods）并不需要属于同一个类别。一个delegate object 所搭载的所有方法（methods）必须具有相同的原型和形式。然而，这些方法（methods）可以即有 static 也有 non-static，可以由一个或多个不同类别的成员组成。

3) 一个 delegate type 的声明在本质上是创建了一个新的 subtype instance，该 subtype 派生自.NET library framework 的abstract base classes Delegate 或 MulticastDelegate，它们提供一组 public methods 用以询访delegate object 或其搭载的方法（methods）

声明 Delegate Type

一个delegate type 的声明一般由四部分组成：(a)访问级别；(b)关键字delegate；(c)返回型别，以及该delegate type 所搭载之方法的声明形式（signature）；(d)delegate type 的名称，被放置于返回型别和方法的声明形式（signature）之间。例如，下面声明了一个public delegate type Action，用来搭载“没有参数并具有void 返回型别”的方法：

public delegate void Action();

一眼看去，这与函数定义惊人的相似；唯一的区别就是多了delegate 关键字。增加该关键字的目的就在于：要通过关键字（keyword）——而非字元（token）——使普通的成员函数与其它形似的语法形式区别开来。这样就有了virtual,static, 以及delegate 用来区分各种函数和形似函数的语法形式。

定义 Delegate Handle

在C# 中我们无法声明全局对象；每个对象定义必须是下述三种之一：局部对象；或者型别的对象成员；或者函数参数列表中的参数。现在我只向你展示delegate type 的声明。之后我们再来看如何将其声明为类别中的成员。

C# 中的delegate type 与class, interface, 以及array types 一样，属于reference type。每个reference type 被分为两部分：

一个具名的 句柄（named handle），由我们直接操纵；以及

一个该句柄所属型别的不具名对象（unamed object），由我们通过句柄间接进行操纵。必须经由new 显式的创建该对象。

定义reference type 是一个“两步走”的过程。当我们写：

Action theAction;

的时候，theAction代表“delegatetype Action 之对象”的一个handle（句柄），其本身并非delegate object。缺省情况下，它被设为null。如果我们试图在对其赋值（译注：assigned，即与相应型别的对象做attachment）之前就使用它，会发生编译期错误。例如，语句：

theAction();

会唤起theAction 所搭载的方法（method(s)）。然而，除非它在定义之后、使用之前被无条件的赋值（译注：assigned，即与相应型别的对象做attachment），否则该语句会引发编译期错误并印出相关信息。

为 Delegate Object 分配空间

在这一节中，为了以最小限度的涉及面继续进行阐述，我们需要访问一个静态方法（static method）和一个非静态方法（non-static method），就此我采用了一个Announce class。该类别的announceDate 静态方法（static method）以long form 的形式（使用完整单字的冗长形式）打印当前的日期到标准输出设备：

Monday, February 26, 2001

非静态方法（non-static method）announceTime 以short form 的形式（较简短的表示形式）打印当前时间到标准输出设备：

00:58

前两个数字代表小时，从午夜零时开始计算，后两个数字代表分钟。Announceclass 使用了由.NET class framework 提供的DateTime class。Announce类别的定义如下所示。

publicclass Announce

{

   public static void announceDate()

   {

      DateTime dt = DateTime.Now;

      Console.WriteLine( "Today''''s dateis {0}",

                         dt.ToLongDateString());

   }

   public void announceTime()

   {

      DateTime dt = DateTime.Now;

      Console.WriteLine( "The current timenow is {0}",

                         dt.ToShortTimeString());

   }

}

要让theAction 搭载上述方法，我们必须使用new 表达式创建一个 Action delegate type（译注：即创建一个该类别的对象）。要搭载静态方法，则传入构造函数的引数由三部分组成：该方法所属类别的名称；方法的名称；分隔两个名称用的dot operator（.）：

theAction = new Action( Announce.announceDate );

要搭载非静态方法，则传入构造函数的引数也由三部分组成：该方法所属的类别对象名称；方法的名称；分隔两个名称用的dot operator（.）：

Announce an = new Announce();

theAction   = new Action( an.announceTime );

可以注意到， theAction 被直接赋值，事先没有做任何检查（比如，检查它是否已经指代一个堆中的对象，如果是，则先删除该对象）。在C# 中，存在于 managed heap（受托管的堆）中的对象由运行期环境对其施以垃圾收集动作（garbagecollected）。我们不需要显式的删除那些经由 new 表达式分配的对象。

在程序的 managed heap（受托管的堆）中，new 表达式既可以为独个对象做分配

HelloUser myProg = new HelloUser();

也可以为数组对象做分配

string [] messages =new string[ 4 ];

分配语句的形式为：型别的名称，后跟关键字 new，后跟一对圆括弧（表示单个对象）或者方括号（表示数组对象）[1]。（在 C# 语言设计中的一个普遍特征就是，坚持使用单一明晰的形式来区别不同的功用。）

一个快速的概览：Garbage Collection（垃圾收集）

如下述数组对象所示，当我们在managed heap（受托管的堆）中为reference type 分配了空间：

int [] fib = new int[6]{ 1,1,2,3,5,8 };

对象自动的维护“指向它的句柄（handles）”之数目。在这个例子中，被fib 所指向的数组对象有一个关联的引用计数器被初始化为1。如果我们现在初始化另一个句柄，使其指向fib 所指代的数组对象：

int [] notfib = fib;

这次初始化导致了对fib 所指代数组对象的一次shallow copy（浅层拷贝）。这就是说，notfib现在也指向fib 所指向的数组对象。该数组对象所关联的引用计数变成了2。

如果我们经由notfib 修改了数组中某个元素，比如

notfib [ 0 ] = 0;

这个改变对于fib 也是可见的。如果这种对同一个对象的多重访问方式并非所需，我们就需要编写代码，做一个deep copy（深层拷贝）。例如，

// 分配另一个数组对象

notfib = new int [6];

// 从notfib 的第0个元素开始，

// 依次将fib 中的元素拷贝到notfib 中去。

// 见注释[2]

fib.CopyTo( notfib, 0 );

notfib 现在并不指代fib 所指代的那个对象了。先前被它们两个同时指向的那个对象将其关联的引用计数减去1。notfib 所指代对象的初始引用计数为1。如果我们现在也将fib 重新赋值为一个新的数组对象——例如，一个包含了Fibonacci数列前12个数值的数组：

fib = new int[12]{ 1,1,2,3,5,8,13,21,34,55,89,144 };

对于之前被fib 所指代的那个数组对象，其现在的引用计数变成了0。在managed heap（受托管的堆）中，当垃圾收集器（garbage collector）处于活动状态时，引用计数为0的对象被其作上删除标记。

定义 Class Properties

现在让我们将delegate object 声明为testHarness class 的一个私有静态（private static）成员。例如[3]，

public class testHarness

{

   public delegate void Action();

   static private Action theAction;

   // ...

}

下一步我们要为这个delegate 成员提供读写访问机制。在C# 中，我们不要提供显式的内联方法（inline methods）用来读写非公有的数据成员。取而代之，我们为具名的属性（named property）提供get 和set 访问符（accessors）。下面是个简单的delegate property。我们不妨将其称为Tester：

 

public class testHarness

{

   static private Action theAction;

   static public Action Tester

   {

      get{ return theAction; }

      set{ theAction = value; }

   }

   // ...

}

Property（属性）既可以封装静态数据成员，也可以封装非静态数据成员。Tester就是delegate type Action 的一个static property（静态属性）。

get必须以property（属性）的型别作为返回型别。在这个例子中，其直接返回所封装的对象。如果采用“缓式分配（lazyallocation）”，get可以在初次被唤起的时候建构并存放好对象，以便后用。

类似的，如果我们希望 property（属性）能够支持写入型访问，我们就提供set accessor。set中的value 是一个条件型关键字（conditional-keyword）。也就是说，value仅在set property 中具有预定义的含义（译注：也就是说，value仅在set 代码段中被看作一个关键字）：其总是代表“该property（属性）之型别”的对象。在我们的例子中，value是Action 型别的对象。在运行期间，其被绑定到赋值表达式的右侧。在下面的例子中，

Announce an = new Announce();

testHarness.Tester  = new testHarness.Action( an.announceTime );

set 以内联（inline）的方式被展开到Tester 出现的地方。value对象被设置为由new 表达式返回的对象。

唤起 Delegate Object

如之前所见，要唤起由delegate 所搭载的方法，我们对delegate 施加 call operator（圆括弧对）：

testHarness.Tester();

这一句唤起了Tester property 的get accessor；get accessor返回theAction delegate handle。如果theAction 在此刻并未指向一个delegate object，那么就会有异常被抛出。从类别外部实行唤起动作的规范做法（delegate-test-and-execute，先实现代理，再测试，最后执行之）如下所示：

if (testHarness.Tester != null )

   testHarness.Tester();

对于 testHarness class，我们的方法只简单的封装这样的测试：

static public void run()

{

   if  (theAction != null)

      theAction();

}

关联多个 Delegate Objects

要让一个delegate 搭载多个方法，我们主要使用 += operator 和 -= operator。例如，设想我们定义了一个testHashtable class。在构造函数中，我们把各个关联的测试加入到testHarness 中：

public class testHashtable

{

   public void test0();

   public void test1();

   testHashtable()

   {

      testHarness.Tester += new testHarness.Action( test0 );

      testHarness.Tester += new testHarness.Action( test1 );

   }

   // ...

}

同样，如果我们定义一个testArrayList class，我们也在default constructor 中加入关联的测试。可以注意到，这些方法是静态的。

public class testArrayList

{

   static public void testCapacity();

   static public void testSearch();

   static public void testSort();

   testArrayList()

   {

      testHarness.Tester += new testHarness.Action(testCapacity);

      testHarness.Tester += new testHarness.Action(testSearch);

      testHarness.Tester += new testHarness.Action(testSort);

   }

   // ...

}

当testHarness.run 方法被唤起时，通常我们并不知道testHashtable 和testArrayList 中哪一个的方法先被唤起；这取决于它们构造函数被唤起的顺序。但我们可以知道的是，对于每个类别，其方法被唤起的顺序就是方法被加入delegate 的顺序。

Delegate Objects 与 Garbage Collection（垃圾收集）

考察下列局部作用域中的代码段：

{

   Announce an = new Announce();

   testHarness.Tester +=  new testHarness.Action( an.announceTime );

}

当我们将一个非静态方法加入到delegate object 中之后，该方法的地址，以及“用来唤起该方法，指向类别对象的句柄（handle）”都被存储起来。这导致该类别对象所关联的引用计数自动增加。

an 经由new 表达式初始化之后，managed heap（受托管的堆）中的对象所关联的引用计数被初始化为1。当 an 被传给delegate object 的构造函数之后，Announce对象的引用计数增加到2。走出局部作用域之后，an的生存期结束，该引用计数减回到1——delegate object还占用了一个。

好消息是，如果有一个delegate 引用了某对象的一个方法，那么可以保证该对象会直到“delegate object 不再引用该方法”的时候才会被施以垃圾收集处理[4]。我们不用担心对象会在自己眼皮底下被贸然清理掉了。坏消息是，该对象将持续存在（译注：这可能是不必要的），直到delegate object 不再引用其方法为止。可以使用-= operator 从delegate object 中移除该方法。例如下面修正版本的代码；在局部作用域中，announceTime先被设置、执行，然后又从delegate object 中被移除。

{

   Announce an = new Announce();

   Action act = new testHarness.Action( an.announceTime );

   testHarness.Tester += act;

   testHarness.run();

   testHarness.Tester -= act;

}

我们对于设计testHashtable class 的初始想法是，实现一个析构函数用以移除在构造函数中加入的测试用方法。然而，C#中的析构函数调用机制与C++ 中的却不大相同[5]。C# 的析构函数既不会因为对象生存期结束而跟着被唤起，也不会因为释放了对象最后一个引用句柄（reference handle）而被直接唤起。事实上，析构函数仅在垃圾收集器作垃圾收集时才被调用，而施行垃圾收集的时机一般是无法预料的，甚至可以根本就没施行垃圾收集。

C# 规定，资源去配动作被放进一个称为Dispose 的方法中完成，用户可以直接调用该方法：

public void Dispose ()

{

   testHarness.Tester -= new testHarness.Action(test0 );

   testHarness.Tester -= newtestHarness.Action( test1 );

}

如果某类别定义了一个析构函数，其通常都会唤起Dispose。

访问底层的类别接口

让我们再回头看看先前的代码：

{

   Announce an = new Announce();

   Action act = new testHarness.Action ( an.announceTime );

   testHarness.Tester += act;

   testHarness.run();

   testHarness.Tester -= act;

}

另一种实现方案是，先检查Tester 当前是否已经搭载了其它方法，如果是，则保存当前的委托列表（delegation list），将Tester 重置为act，然后调用run，最后将Tester 恢复为原来的状态。

我们可以利用底层的Delegate 类别接口来获知delegate 实际搭载的方法数目。例如，

if (testHarness.Tester != null && testHarnest.GetInvocationList().Length !=0 )

   {

      Action oldAct = testHarness.Tester;

      testHarness.Tester = act;

      testHarness.run();

      testHarness.Tester = oldAct;

   }  

else{ ... }

GetInvocationList 返回 Delegate class objects 数组，数组的每个元素即代表该delegate 当前搭载的一个方法。Length是底层Array class 的一个property（属性）。Array class 实现了C# 内建数组型别的语义[6]。

经由Delegate class 的Method property，我们可以获取被搭载方法的全部运行期信息。如果方法是非静态的，那么经由Delegate class 的Target property，我们更可以获取调用该方法之对象（译注：即该方法所属类别的那个对象）的全部运行期信息。在下面例子中，Delegate的methods（方法） 和properties（属性）用红色表示：

If(testHarness.Tester != null )

{

   Delegate [] methods = testHarness.Tester.GetInvocationList();

   foreach ( Delegate d in methods )

   {

      MethodInfo theFunction = d.Method;

      Type theTarget   = d.Target.GetType();

   // 好的：现在我们可以知道 delegate 所搭载方法的全部信息

   }

}

总结

希望本文能够引起你对C# delegate type 的兴趣。我认为delegate type 为C# 提供了一种创新性的“pointer to class method（类别方法之指针）”机制。或许本文还引起了你对C# 语言以及.NET class framework 的兴趣。

注释

[1] 对于C++ 程序员来说，有两点值得一题：(a)需要在对象的型别名称之后放一对圆括弧作为default constructor，以及(b)用于数组下标的方括号要放在型别与数组名称之间。

[2] C# 中内建的数组是一种由.NET class library 提供的Array class 之对象。Array class 的静态方法和非静态方法都可以被C# 内建数组对象使用。CopyTo是Array 的一个非静态方法。

[3] 与Java 一样，C#中的成员声明包括其访问级别。缺省的访问级别是private。

[4] 类似的，C++标准要求，被引用的临时对象必须直到引用的生存期结束时才能够被销毁。

[5] 在内部实现中，析构函数甚至都不曾存在过。一个类别的析构函数会被转换成virtual Finalize 方法。

[6] 在C# 中，一个条件判别式的结果必须得到Boolean 型别。对 Length 值的直接判别，如 if (testHarness.Length)，并不是合法的条件判断。整型值无法被隐式的转换为Boolean 值。

namespace DelegateTest
{
    public class testHarness
    {
        public delegate void Action();

        static private Action theAction;
        static public Action Tester
        {

            get 
            { 
                return theAction; 
            }

            set 
            { 
                theAction = value; 
            }
        }
    }

    public class testHashtable
    {

        public void test0()
        {
            Console.WriteLine("testHashtable:test0");
        }

        public void test1()
        {
            Console.WriteLine("testHashtable:test1");
        }

        public testHashtable()
        {

            testHarness.Tester += new testHarness.Action(test0);

            testHarness.Tester += new testHarness.Action(test1);

        }

        // ...

    }

    public class testArrayList
    {

        static public void testCapacity()
        {
            Console.WriteLine("static testArrayList:testCapacity");
        }

        static public void testSearch()
        {
            Console.WriteLine("static testArrayList:testSearch");
        }

        static public void testSort()
        {
            Console.WriteLine("static testArrayList:testSort");
        }

        public testArrayList()
        {

            testHarness.Tester += new testHarness.Action(testCapacity);

            testHarness.Tester += new testHarness.Action(testSearch);

            testHarness.Tester += new testHarness.Action(testSort);

        }

        // ...

    }

    class Program
    {
        static void Main(string[] args)
        {
            testHashtable test1 = new testHashtable();
            testArrayList test2 = new testArrayList();

           if (testHarness.Tester != null)
           {
               if(testHarness.Tester.GetInvocationList().Length != 0)
                   testHarness.Tester();
           }
        }
    }
}