C# 如何创建超过八个值的ValueTuple列表？

如何创建ValueTuple超过八个值的列表，如下所示：

(int Id, string FirstName, string LastName, int Vek, int City, int Zip, int Country, int Street, int Firm, int Age, int Bank, bool IsActive) person =
   (1, "Bill", "Gates", 4, 5, 6, 7, 8, 9, 10, 11, true);

你不能

您必须创建自己的元组，尽管有一些方法可以将元组插入元组和其他类型中

然而，在一切平等的情况下，听起来你想创建一个类，并在所有类型和命名的荣耀中拥有所有世界中最好的

---

公共类元组：IsStructuralEquatable、IsStructuralCompatible、iCompatible、ITupleInternal、ITuple{
专用只读T1 m_项1；
专用只读T2 m_项2；
专用只读T3 m_项目3；
专用只读T4 m_项目4；
专用只读T5 m_项目5；
专用只读T6 m_项6；
专用只读T7 m_项7；
私有只读TRest m_Rest；
公共T1项1{get{return m_Item1；}}
公共T2项2{get{return m_Item2；}}
公共T3项3{get{return m_Item3；}}
公共T4项4{get{return m_Item4；}}
公共T5项目5{get{return m_Item5；}}
公共T6项6{get{return m_Item6；}}
公共T7项7{get{return m_Item7；}}
公共树Rest{get{return m_Rest；}
公共元组（T1项1、T2项2、T3项3、T4项4、T5项5、T6项6、T7项7、TRest rest）{
如果（！（其余为ITupleInternal））{
抛出新的ArgumentException（Environment.GetResourceString（“ArgumentException_TupleLastargumentNotTuple”）；
}
m_Item1=Item1；
m_Item2=Item2；
m_Item3=Item3；
m_Item4=Item4；
m_Item5=Item5；
m_Item6=Item6；
m_Item7=Item7；
m_Rest=休息；
}
公共覆盖布尔等于（对象obj）{
返回（（IsStructuralEquatable）this）.Equals（obj，EqualityComparer.Default）；；
}
布尔IStructuralEquatable.Equals（对象其他，IEqualityComparer比较器）{
if（other==null）返回false；
Tuple objTuple=其他为Tuple；
if（objTuple==null）{
返回false；
}
返回comparer.Equals（m_Item1，objTuple.m_Item1）和comparer.Equals（m_Item2，objTuple.m_Item2）和comparer.Equals（m_Item3，objTuple.m_Item3）和comparer.Equals（m_Item4，objTuple.m_Item4）和comparer.Equals（m_Item5，objtu.m_Item5）和comparer.Equals（m_Item6，objtu Item7）和comparer.Equals（m_-Rest，objTuple.m_-Rest）；
}
Int32 IComparable.CompareTo（对象对象）{
返回（（IStructuralComparable）this.CompareTo（obj，Comparer.Default）；
}
Int32 IStructuralComparable.CompareTo（对象其他，IComparer比较器）{
if（other==null）返回1；
Tuple objTuple=其他为Tuple；
if（objTuple==null）{
抛出新的ArgumentException（Environment.GetResourceString（“ArgumentException\u TupleIncorrectType”，this.GetType（）.ToString（），“other”）；
}
int c=0；
c=比较器.Compare（m_Item1，objTuple.m_Item1）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item2，objTuple.m_Item2）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item3，objTuple.m_Item3）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item4，objTuple.m_Item4）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item5，objTuple.m_Item5）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item6，objTuple.m_Item6）；
如果（c！=0）返回c；
c=比较器.Compare（m_Item7，objTuple.m_Item7）；
如果（c！=0）返回c；
返回comparer.Compare（murest，objTuple.murest）；
}
公共覆盖int GetHashCode（）{
返回（（IsStructuralEquatable）this）.GetHashCode（EqualityComparer.Default）；
}
Int32 IStructuralEquatable.GetHashCode（IEqualityComparer比较器）{
//在这种情况下，我们希望有一个有限的散列。我们将使用元组的最后8个元素
itupleinternalt=（ITupleInternal）m_Rest；
如果（t.Length>=8）{返回t.GetHashCode（comparer）；}
//在本例中，rest成员只有不到8个元素，因此我们需要将我们的一些元素与rest中的元素结合起来
int k=8-t.长度；
开关（k）{
案例1：
返回Tuple.CombineHashCodes（comparer.GetHashCode（m_Item7），t.GetHashCode（comparer））；
案例2：
返回Tuple.combinehashcode（comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
案例3：
返回Tuple.combinehashcode（comparer.GetHashCode（m_Item5）、comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
案例4：
返回Tuple.CombineHashCodes（comparer.GetHashCode（m_Item4）、comparer.GetHashCode（m_Item5）、comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
案例5：
返回Tuple.CombineHashCodes（comparer.GetHashCode（m_Item3）、comparer.GetHashCode（m_Item4）、comparer.GetHashCode（m_Item5）、comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
案例6：
返回Tuple.CombineHashCodes（comparer.GetHashCode（m_Item2）、comparer.GetHashCode（m_Item3）、comparer.GetHashCode（m_Item4）、comparer.GetHashCode（m_Item5）、comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
案例7：
返回Tuple.CombineHashCodes（comparer.GetHashCode（m_Item1）、comparer.GetHashCode（m_Item2）、comparer.GetHashCode（m_Item3）、comparer.GetHashCode（m_Item4）、comparer.GetHashCode（m_Item5）、comparer.GetHashCode（m_Item6）、comparer.GetHashCode（m_Item7）、t.GetHashCode（comparer））；
}
Assert（false，“计算元组哈希代码时遗漏了所有案例”）；
返回-1；
}
Int32 ITupleInternal.GetHashCode（IEqualityComparer比较器）{
返回（（IsStructuralEquatable）this）.GetHashCode（比较器）；
}
公共重写字符串ToString（）{
架线工
public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple {

    private readonly T1 m_Item1;
    private readonly T2 m_Item2;
    private readonly T3 m_Item3;
    private readonly T4 m_Item4;
    private readonly T5 m_Item5;
    private readonly T6 m_Item6;
    private readonly T7 m_Item7;
    private readonly TRest m_Rest;

    public T1 Item1 { get { return m_Item1; } }
    public T2 Item2 { get { return m_Item2; } }
    public T3 Item3 { get { return m_Item3; } }
    public T4 Item4 { get { return m_Item4; } }
    public T5 Item5 { get { return m_Item5; } }
    public T6 Item6 { get { return m_Item6; } }
    public T7 Item7 { get { return m_Item7; } }
    public TRest Rest { get { return m_Rest; } }

    public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) {
        if (!(rest is ITupleInternal)) {
            throw new ArgumentException(Environment.GetResourceString("ArgumentException_TupleLastArgumentNotATuple"));
        }

        m_Item1 = item1;
        m_Item2 = item2;
        m_Item3 = item3;
        m_Item4 = item4;
        m_Item5 = item5;
        m_Item6 = item6;
        m_Item7 = item7;
        m_Rest = rest;
    }

    public override Boolean Equals(Object obj) {
        return ((IStructuralEquatable) this).Equals(obj, EqualityComparer<Object>.Default);;
    }

    Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer) {
        if (other == null) return false;

        Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple = other as Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>;

        if (objTuple == null) {
            return false;
        }

        return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6) && comparer.Equals(m_Item7, objTuple.m_Item7) && comparer.Equals(m_Rest, objTuple.m_Rest);
    }

    Int32 IComparable.CompareTo(Object obj) {
        return ((IStructuralComparable) this).CompareTo(obj, Comparer<Object>.Default);
    }

    Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer) {
        if (other == null) return 1;

        Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple = other as Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>;

        if (objTuple == null) {
            throw new ArgumentException(Environment.GetResourceString("ArgumentException_TupleIncorrectType", this.GetType().ToString()), "other");
        }

        int c = 0;

        c = comparer.Compare(m_Item1, objTuple.m_Item1);

        if (c != 0) return c;

        c = comparer.Compare(m_Item2, objTuple.m_Item2);

        if (c != 0) return c;

        c = comparer.Compare(m_Item3, objTuple.m_Item3);

        if (c != 0) return c;

        c = comparer.Compare(m_Item4, objTuple.m_Item4);

        if (c != 0) return c;

        c = comparer.Compare(m_Item5, objTuple.m_Item5);

        if (c != 0) return c;

        c = comparer.Compare(m_Item6, objTuple.m_Item6);

        if (c != 0) return c;

        c = comparer.Compare(m_Item7, objTuple.m_Item7);

        if (c != 0) return c;

        return comparer.Compare(m_Rest, objTuple.m_Rest);
    }

    public override int GetHashCode() {
        return ((IStructuralEquatable) this).GetHashCode(EqualityComparer<Object>.Default);
    }

    Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer) {
        // We want to have a limited hash in this case.  We'll use the last 8 elements of the tuple
        ITupleInternal t = (ITupleInternal) m_Rest;
        if(t.Length >= 8) { return t.GetHashCode(comparer); }

        // In this case, the rest memeber has less than 8 elements so we need to combine some our elements with the elements in rest
        int k = 8 - t.Length;
        switch(k) {
            case 1:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 2:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 3:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 4:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 5:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 6:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            case 7:
            return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
        }
        Contract.Assert(false, "Missed all cases for computing Tuple hash code");
        return -1;
    }

    Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer) {
        return ((IStructuralEquatable) this).GetHashCode(comparer);
    }
    public override string ToString() {
        StringBuilder sb = new StringBuilder();
        sb.Append("(");
        return ((ITupleInternal)this).ToString(sb);
    }

    string ITupleInternal.ToString(StringBuilder sb) {
        sb.Append(m_Item1);
        sb.Append(", ");
        sb.Append(m_Item2);
        sb.Append(", ");
        sb.Append(m_Item3);
        sb.Append(", ");
        sb.Append(m_Item4);
        sb.Append(", ");
        sb.Append(m_Item5);
        sb.Append(", ");
        sb.Append(m_Item6);
        sb.Append(", ");
        sb.Append(m_Item7);
        sb.Append(", ");
        return ((ITupleInternal)m_Rest).ToString(sb);
    }

    /// <summary>
    /// The number of positions in this data structure.
    /// </summary>
    int ITuple.Length
    {
        get
        {
            return 7 + ((ITupleInternal)Rest).Length;
        }
    }

    /// <summary>
    /// Get the element at position <param name="index"/>.
    /// </summary>
    object ITuple.this[int index]
    {
        get
        {
            switch (index)
            {
                case 0:
                    return Item1;
                case 1:
                    return Item2;
                case 2:
                    return Item3;
                case 3:
                    return Item4;
                case 4:
                    return Item5;
                case 5:
                    return Item6;
                case 6:
                    return Item7;
            }

            return ((ITupleInternal)Rest)[index - 7];
        }
    }
}