派生自 System.Threading.Tasks.Task - C# 中的“打结”

• 下载源代码、VS2012项目以及调试和发布二进制文件 - 32.8 KB

引言

也许你想在 C# 程序中异步运行一些计算或其他操作，并且想使用 `Task`¹。预期的方法是直接向任务工厂提供你要运行的代码，通常以 lambda 表达式的形式：

    Task t = Task.Factory.StartNew( () => MyLongAsynchronousCalculation() );

每种技术总的来说都有其优缺点，但在使用 `Task` 的特定情况下，组合通常是首选。就连 Jon Skeet² 这个权威人士也说：

    I wouldn't personally extend Task<T>, I'd compose it instead.3

但是……为什么呢？几乎所有当前面向对象语言的一个缺点是它们没有对委托的一等支持；这使得继承比组合更适合许多需要使用另一个类的行为的设计问题。而且，.NET Framework 的开发者也深谙面向对象的正确设计⁴，他们本可以像 Framework 中的许多其他类一样将 `Task` 类设为 sealed，以防止继承——但他们没有。

一旦你尝试继承 `Task`，你就会发现主要问题：`Task` 将要运行的代码作为 `Action` 委托参数传递给它的构造函数，并且它不提供任何可以在 `Task` 构建后使用的该委托的 setter——即使你还没有立即启动 `Task`。在构造函数中，你无法让该委托指向你正在创建的 `Task` 子类的实例。

    class D : Task {
        public D() : base(??) { }
        public void Run() { … }
    }
    …
    D d = new D();

或者你没有卡住？这就是本文将要描述的：一种正确派生 `Task` 以使其运行你的子类实例中的方法的方式。这种技术借鉴自惰性函数式语言⁵，称为“打结”（Tying The Knot）。^{6, 7}

在函数式语言中，所有值都是不可变的。如果一个值有多个字段，它们是不能被修改的。那么如何构造一个引用自身的结构呢？这在（例如）循环列表或非 DAG 图结构中会出现。

例如，考虑将范围 [0..1) 内的有理数表示为基数为 10 的数字的链表。有理数 \(\frac{1}{8} = 0.125\) 是有限的，所以很容易。但 \(\frac{1}{7} = 0.\overline{142857}\) 是一个不终止的循环小数呢？⁹

    var OneEighth = new SinglyLinkedList<int> { 1, 2, 5 };
    Console.WriteLine("1/8 = " + string.Join(",", OneEighth.Take(30).Select(e => e.ToString())));
        Console: 1/8 = 1,2,5

    var OneSeventh = new SinglyLinkedList<int> { 1, 4, 2, 8, 5, 7 };
    OneSeventh.Next.Next.Next.Next.Next.Next = OneSeventh;
    Console.WriteLine("1/7 = " + string.Join(",", OneSeventh.Take(30).Select(e => e.ToString())));
        Console: 1/7 = 1,4,2,8,5,7,1,4,2,8,5,7,1,4,2,8,5,7,1,4,2,8,5,7,1,4,2,8,5,7

在惰性函数式语言（如 Haskell¹⁰）中，你必须以不同的方式处理，因为列表是不可变的。但该语言有一个名为“letrec”的特性，代表“let 递归”（其中“let”是语言中的绑定构造），它允许你在一个变量尚未计算出来时引用它——只要你不要**使用**它！

    oneEighth = 1 : 2 : 5

    oneSeventh = let x = 1 : 4 : 2 : 8 : 5 : 7 : x
                 in  x

鉴于 C# 不是一种惰性求值语言¹²，如何实现打结呢？

我们需要延迟求值，并且能够在一个数据结构构建完成后绑定一个值。两个相关的语言机制将协同工作。首先，为了实现延迟求值，我们将引入一个额外的间接层¹³，通过使用委托——方法指针；在 C# 中，这通常会写成 lambda 表达式。其次，为了实现**事后**绑定，我们将使用 C# 出色的变量捕获实现——C# 几乎拥有真正的闭包¹⁴——在数据结构构建完成后绑定一个值。

组合的工作方式如下：

1. 创建一个变量来提供一个值的绑定位置，但不要提供该值。
2. 创建一个 lambda 表达式，它捕获该变量，并返回该变量中的值。由于创建 lambda 表达式时不会解引用变量来获取值，所以这是可以的。
3. 创建数据结构，将 lambda 表达式传递给创建例程，该例程会将其保存在某处，但暂时不调用它。
4. 将数据结构存储到被捕获的变量中。
5. 求值 lambda 表达式，该表达式将解引用变量以获取数据结构，并对其进行某些操作（例如将其存储在它自身的某个内部字段中）。

class D : T {
    public D(Action a) : base(a) { }
    …
        Action f = () => this.Foo();
    …
}

    …
        D d = null;			// 1: Create a variable to hold a D.
        Action g = () => d.Foo();	// 2: Capture the variable in our lambda.
        d = new D(g);			// 3: Create a new D, passing in our lambda,
                                        //    and store it in the variable we captured.
        d.M();				// 4: Execute the method that is going to
                                        //    run our Action and call d.Foo().  
   …

如前所述，`Task` 接受一个 `Action`，当 `Task` 启动时，它就是需要运行的代码。¹⁵ 我们希望它运行我们子类中的一个方法。现在只剩下两个问题需要解决：`Action` 从何而来，以及它如何传递给 `Task`？

回答第一个问题：`Action` 以及派生实例将在一个工厂方法中创建。我们派生类的构造函数将是受保护的访问级别，因此开发者不能直接创建它。

回答第二个问题：让我们的派生类拥有一个构造函数，除了用于初始化自身的其他参数外，它还可以接受 `Action` 并立即将其传递给基类，这很容易。

    protected D(Action a) : base(a) { … }

总之，抽象泛型类 `DeriveFromTaskBase` 的代码在此文章关联的zip 归档中，所以我只会在这里评论亮点。

DeriveFromTaskBase 的公共 API

`DeriveFromTaskBase` 的公共 API 包括创建实例并启动它的工厂方法 `Create`，以及一个必须重写的抽象方法 `Run`，以提供继承 `Task` 的目的的子类特定计算。

`Create` 工厂方法接受一个可选的 `Action<T>`，称为 `beforeStartInitializer`，它在实例启动之前运行。它的目的是提供一个初始化实例的机会，并弥补只有一个零参数构造函数的不足。你提供的 `Action<T>` 将接收实例本身，并可以设置该实例的属性或调用其方法。（请记住，当你使用 lambda 表达式创建 `Action` 时，你可以捕获任何你当时需要的值。）如果你还（或另外）可以在构造时执行某些操作（这些操作必然不能依赖于任何外部输入），你可以（可选地）重写 `Constructor` 方法并执行该初始化。

    /// <summary>
    /// Abstract base class for classes that want to derive from Task.
    /// </summary>
    public abstract class DeriveFromTaskBase : Task
    {
        #region Public interface
        public static T Create<T>(Action<T> beforeStartInitializer = null)
            where T : DeriveFromTaskBase, new()
        {
            …
        }

        public virtual void Constructor() { }

        public abstract void Run();
        #endregion

派生实例的构造

构造函数相当简单：引用一个保存间接 `Action` 的静态字段，它将该 `Action` 传递给基类 `Task`，然后调用（可选的）`Constructor` 方法。

        private static Action thisDeferred;

        protected DeriveFromTaskBase() : base(thisDeferred)
        {
            Constructor();
        }

“打结”并创建派生实例的工厂

有趣的是，有两个结要打！

工厂方法会获取一个锁以确保序列化。然后它提供一个待创建实例的位置，并提供一个真正 `Action` 的位置。它通过创建间接 `Action` 来打第一个结，该间接 `Action` 通过捕获真正 `Action` 的位置来调用它。然后它执行 `new T()` 来**最终**创建你真正想要的派生实例。它通过创建真正 `Action` 来打第二个结，该真正 `Action` 捕获新实例的位置。在完成所有这些之后，它启动实例——`Task` 调用其启动 `Action`，该启动 `Action` 调用真正 `Action`，后者调用实例的 `Run` 方法，最后 `Task` 就启动了！

        private static object createLock = new object();
        private static Action thisDeferred;

        private static T Create<T>(Action<T> beforeStartInitializer = null)
            where T : DeriveFromTaskBase, new()
        {
            T t = null;

            lock (createLock)
            {
                Action thisDeferredInner = null;

                thisDeferred = () => thisDeferredInner();

                t = new T();

                thisDeferredInner = () =>
                    {
                        if (null != beforeStartInitializer)
                            beforeStartInitializer(t);
                        t.Run();
                    };
            }
            t.Start();
            return t;
        }

(到目前为止，你应该不需要注释就能理解上面的代码……但别担心：源代码中有注释，都在 zip 文件中。）

文章摘要

是否值得？这取决于。对于当前情况，利用 `Task` 来运行需要持续状态的复杂代码，如果你从零开始，那么最简单的方法是编写一个类，它不继承 `Task`，而是简单地拥有一个 `Task` 实例。也就是说，使用组合。

但是，YNK。¹⁶ 现在这个类已经为你写好了（并解释了！），你可能会发现因为各种原因你需要 `Task` 来执行复杂的计算，并且跟踪计算实例和 `Task` 实例之间的关系可能会很烦人。

此外，在一般情况下（脱离 `Task`），了解如何将**打结**作为一种通用技术，以及你具体如何用 C# 中的 lambda 和变量捕获来实现它，可能会对你有所帮助（也很有趣）。我希望如此。

哦，还有一件事。既然你已经理解了上一节，你应该可以轻松理解文章顶部的图表。你说什么？你看不到？好吧，这不是你的错。事实是，它并不是一个很好的图表，只是我能做的最好的。请随时提供一个更好的图表（在评论中告诉我），我很乐意将其替换掉我提出的图表，并给你记上功劳。

¹ 也就是说，一个 `System.Threading.Tasks.Task`。

²Jon Skeet 的《C# 深入》是一本优秀的著作，Jon Skeet 的博客也是如此。

³ 请参阅 SO 上 Jon Skeet 的回答。

⁴ 他们写了一本关于这个的书：《Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries》。

⁵ 例如，Haskell。

⁶ 《打结》的完整描述。打结的经典算法是repmin，这是一种单遍算法，用于构建一个与给定树形状相同的树，只是每个叶子都具有原始树中的最小叶子值。

⁷ 这些脚注到底是怎么回事？这是一个 CodeProject 网页文章，而不是学术论文！⁸

⁸ 我不知道，我只是觉得会很有趣。

⁹ 这里有一个读者练习：给定这种范围 [0..1) 内的有理数表示，编写相等函数。确保它发现以下两个相同的数字表示，\(\frac{1}{5} = 0.2 = 0.1\overline{9}\)，它们是相等的：

¹⁰ 同上。¹¹ 4。

¹¹ 哦，天哪！我**一直**想用 Ibid.！

¹² 惰性求值（维基百科）意味着一个表达式在绑定到变量时不会被求值，而是在使用时才会被求值。几乎所有的语言都使用严格求值，即表达式在绑定到变量（或过程参数）时会被完全求值。事实上，这就是为什么一些日志库有时会竭尽全力使用非语言机制，如 C/C++ 中的预处理器宏，来高效处理格式化消息及其参数：它们试图通过避免对消息参数的求值来提高性能并减少日志记录的开销，除非消息的日志/跟踪级别足够高，足以将日志消息实际写入某个接收器。

¹³ 软件工程基本定理

    We can solve any problem by introducing an extra level of indirection..

¹⁴ 关于 C# 闭包是否是“真正的”闭包存在一些疑问。在维基百科上曾有过激烈的讨论，以及在编程语言博客Lambda The Ultimate上，关于维基百科上关于闭包的文章。有些人只接受“返回绑定”（即允许使用 call-with-current-continuation）的闭包。其他人则认为 C# 3.0 和 Javascript 中的闭包与“真正的”闭包几乎没有区别。

¹⁵ 还有一种将数据传入 `Task` 的方法：在构造时将一个 `Async State Object` 传入。但这与启动 `Action` 存在同样的问题：构造函数运行后没有 setter 可以用来更改 `Async State Object`。你**可以**改为提供一个自定义类包装器来包装实例引用（以及你想要传入的任何其他信息）。在构造时将其传入（填充为 null），但保留其引用。然后，一旦有了新实例的引用，就可以用它来填充其字段，然后启动实例。但是……到那时，你不如用这种方式来做。

¹⁶ YNK = 你永远不知道。