[你必须知道的.NET]第三十二回，，深入.NET 4.0之，Tuple一二

发布日期：2009.06.01 作者：Anytao 
© 2009 Anytao.com ，Anytao原创作品，转贴请注明作者和出处。

Tuple，是函数式编程的概念之一，早见于Elang、F#等动态语言。不过，我第一次听说Tuple还早在2005年园子的Ninputer大牛提出在.NET 2.0实现Tuple的基本想法，我们可以通过以下地址仰慕当时的历史片段： 
探讨.NET 2.0中Tuple的实现方法 
由此可见，Tuple不是.NET 4.0的创造发明，但却是C#趋于函数式编程概念的必要补充。那么，我们首先来看看，什么是Tuple？

Tuple为何物？

什么是Tuple，在汉语上我们将其翻译为元组。Tuple的概念源于数学概念，表示有序的数据集合。在.NET中Tuple被实现为泛型类型，n-Tuple表示有n个元素的Tuple，集合的元素可以是任何类型，例如定义一个3-Tuple表示Date(Year, Month, Day)时可以定义为：

// Release : code01, 2009/05/29
// Author  : Anytao, http://www.anytao.com
var date = Tuple.Create<int, int, int>(2009, 5, 29);

通过Tuple.Create<int, int, int>将定义一个Tuple<int, int, int>实例，该实例实现三个数据成员：

对于Tuple的具体解析我们随后分析，当下仅了解一个大致。

我们可以有两个方面的理解，在.NET中关于Tuple我们有如下的定义：

• 广义上， Tuple就是一种数据结构，通常情况下，其成员的类型及数据是确定的。
• 狭义上，凡是实现了ITuple接口的类型，都是Tuple的实例。在.NET 4.0 BCL中，预定义了8个Tuple类型。例如最简单的Tuple定义为：

public class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable, ITuple
{
}

其他所有的Tuple类型都实现了ITuple接口，该接口被定义为：

interface ITuple
{
    int Size { get; }

    int GetHashCode(IEqualityComparer comparer);
    string ToString(StringBuilder sb);
}

在该接口中，定义了一个只读属性Size、两个覆写方法GetHashCode和ToString，实现该接口的Tuple八大金刚如下：

public class Tuple<T1>
public class Tuple<T1, T2>
public class Tuple<T1, T2, T3>
public class Tuple<T1, T2, T3, T4>
public class Tuple<T1, T2, T3, T4, T5>
public class Tuple<T1, T2, T3, T4, T5, T6>
public class Tuple<T1, T2, T3, T4, T5, T6, T7>
public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>

注：Size属性、ToString(StringBuilder sb)方法，均被实现为显示接口方法，所以只能以接口实例访问，不过ITuple本身被定义internal，意味着我们无法在程序中访问ITuple，何意何解尚不明确。

在下面的定义中，我们将Custom Request封装为Tuple：

// Release : code02, 2009/05/29
// Author  : Anytao, http://www.anytao.com
public class MyRequest
{
    public Tuple<string, Uri, DateTime> GetMyRequest()
    {
        return Tuple.Create<string, Uri, DateTime>("anytao.com", new Uri("http://anytao.net/"), DateTime.Now);
    }
}

为什么要用Tuple呢？这是个值得权衡的问题，上述MyRequest类型中通过3-Tuple对需要的Request信息进行封装，我们当然也可创建一个新的struct来封装，两种方式均可胜任。然则，在实际的编程实践中，很多时候我们需要一种灵活的创建一定数据结构的类型，很多时候新的数据结构充当着“临时”角色，通过大动干戈新类型完全没有必要，而Tuple既是为此种体验而设计的。例如：

• Point {X, Y}，可以表示坐标位置的数据结构。
• Date {Year, Month, Day}，可以表示日期结构；Time {Hour, Minute, Second}，可以表示时间结构；而DateTime {Date, Time}则可以实现灵活的日期时间结构。
• Request {Name, URL, Result}，可以表示Request的若干信息。
• 。。。，随需而取。

Tuple inside

为了对Tuple一探究竟，我们使用Reflector工具打开神秘之门，就实现而言，Tuple类型略显单薄，并没有什么“神奇”的设计，以Tuple<T1, T2>而言，我们可以看到其部分实现：

[Serializable]
public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable, ITuple
{
    // Fields
    private T1 m_Item1;
    private T2 m_Item2;

    // Methods
    public Tuple(T1 item1, T2 item2)
    {
        this.m_Item1 = item1;
        this.m_Item2 = item2;
    }


    string ITuple.ToString(StringBuilder sb)
    {
        sb.Append(this.m_Item1);
        sb.Append(", ");
        sb.Append(this.m_Item2);
        sb.Append(")");
        return sb.ToString();
    }

    int ITuple.Size
    {
        get
        {
            return 2;
        }
    }

    // Properties
    public T1 Item1
    {
        get
        {
            return this.m_Item1;
        }
    }

    public T2 Item2
    {
        get
        {
            return this.m_Item2;
        }
    }

    //More and more...
}

其他的Tuple类型也大致如此，所以我们易于知晓Item1、Item2、…、ItemN是如何被定义的，同时也纳闷Size属性将何去何从，也打消了我们期望通过foreach来遍历Tuple元素的可能，未来如何，只有期待。

不过，对于Tuple而言，因为其元素数量的有限性，虽然能够满足大部分的需求，当时动态体验是我们越来越期望的编程体验。同时，尤其注意public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> 引发的可能ArgumentException，例如：

// Release : code03, 2009/05/31
// Author  : Anytao, http://www.anytao.com
var t8 = Tuple.Create<int, int, int, int, int, int, int, int>(1, 2, 3, 4, 5, 6, 7, 8);
Console.WriteLine(t8.Rest);

将引发异常：

Unhandled Exception: System.ArgumentException: The last element of an eight element tuple must be a Tuple.

提示我们最后的TRest应该为Tuple，所以修改程序为：

// Release : code04, 2009/05/31
// Author  : Anytao, http://www.anytao.com
var trest = Tuple.Create<int>(8);
var t8 = Tuple.Create<int, int, int, int, int, int, int, Tuple<int>>(1, 2, 3, 4, 5, 6, 7, trest);
Console.WriteLine(t8.Rest);

则没有任何问题，究其原因我们很容易从Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>构造方法中找到答案：

public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
{
    if (!(rest is ITuple))
    {
        throw new ArgumentException(Environment.GetResourceString("ArgumentException_TupleLastArgumentNotATuple"));
    }
    this.m_Item1 = item1;
    this.m_Item2 = item2;
    this.m_Item3 = item3;
    this.m_Item4 = item4;
    this.m_Item5 = item5;
    this.m_Item6 = item6;
    this.m_Item7 = item7;
    this.m_Rest = rest;
}

TRest类型参数必须被实现为ITuple，否则引发异常。TRest在某种程度上为元素的扩展带来点方便，但是我仔细想来，总觉此处TRest的设计有点多此一举，既然是类型参数，T1、T2、…、TN其实均可为ITuple实例，何必非拘泥于最后一个。

优略之间

当前，.NET 4.0预定义的Tuple类型仅有8个，所以我们应考虑对于Tuple提供适度扩展的可能， 然而遗憾的是ITuple类型被实现为internal，所以我们无法继承ITuple，只好自定义类似的实现：

优势所在：

• 为方法实现多个返回值体验，这是显然的，Tuple元素都可以作为返回值。
• 灵活的构建数据结构，符合随要随到的公仆精神。
• 强类型。

不足总结：

• 当前Tuple类型的成员被实现为确定值，目前而言，还没有动态决议成员数量的机制，如果你有可以告诉我:-)
• public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>，可能引发ArgumentException。

参考文献

• 探讨.NET 2.0中Tuple的实现方法
• Tuple, a new type on .Net 4.0
• Functional .NET 4.0 - Tuples and Zip