What#39;s the difference between System.ValueTuple and System.Tuple?(System.ValueTuple 和 System.Tuple 有什么区别?)

本文介绍了System.ValueTuple 和 System.Tuple 有什么区别?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我反编译了一些 C# 7 库，发现使用了 ValueTuple 泛型.ValueTuples 是什么，为什么不是 Tuple?

I decompiled some C# 7 libraries and saw ValueTuple generics being used. What are ValueTuples and why not Tuple instead?

https://docs.microsoft.com/en-gb/dotnet/api/system.tuple
https://docs.microsoft.com/en-gb/dotnet/api/system.valuetuple

示例:

您可以很容易地看到使用 System.Tuple 很快就会变得模棱两可.例如，假设我们有一个计算 List<Int> 的总和和计数的方法:

Examples:

You can easily see that working with System.Tuple becomes ambiguous very quickly. For example, say we have a method which calculates a sum and a count of a List<Int>:

public Tuple<int, int> DoStuff(IEnumerable<int> values)
{
    var sum = 0;
    var count = 0;

    foreach (var value in values) { sum += value; count++; }

    return new Tuple(sum, count);
}

在接收端，我们最终得到:

On the receiving end, we end up with:

Tuple<int, int> result = DoStuff(Enumerable.Range(0, 10));

// What is Item1 and what is Item2?
// Which one is the sum and which is the count?
Console.WriteLine(result.Item1);
Console.WriteLine(result.Item2);

您可以将值元组解构为命名参数的方式是该功能的真正强大之处:

The way you can deconstruct value tuples into named arguments is the real power of the feature:

public (int sum, int count) DoStuff(IEnumerable<int> values) 
{
    var res = (sum: 0, count: 0);
    foreach (var value in values) { res.sum += value; res.count++; }
    return res;
}

在接收端:

var result = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {result.Sum}, Count: {result.Count}");

或者:

var (sum, count) = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {sum}, Count: {count}");

编译器好东西:

如果我们查看前面示例的封面，我们可以确切地看到当我们要求它解构时，编译器是如何解释 ValueTuple 的:

[return: TupleElementNames(new string[] {
    "sum",
    "count"
})]
public ValueTuple<int, int> DoStuff(IEnumerable<int> values)
{
    ValueTuple<int, int> result;
    result..ctor(0, 0);
    foreach (int current in values)
    {
        result.Item1 += current;
        result.Item2++;
    }
    return result;
}

public void Foo()
{
    ValueTuple<int, int> expr_0E = this.DoStuff(Enumerable.Range(0, 10));
    int item = expr_0E.Item1;
    int arg_1A_0 = expr_0E.Item2;
}

在内部，编译后的代码使用 Item1 和 Item2，但由于我们使用的是分解的元组，所有这些都从我们身上抽象出来.带有命名参数的元组使用 TupleElementNamesAttribute.如果我们使用单个新变量而不是分解，我们会得到:

Internally, the compiled code utilizes Item1 and Item2, but all of this is abstracted away from us since we work with a decomposed tuple. A tuple with named arguments gets annotated with the TupleElementNamesAttribute. If we use a single fresh variable instead of decomposing, we get:

public void Foo()
{
    ValueTuple<int, int> valueTuple = this.DoStuff(Enumerable.Range(0, 10));
    Console.WriteLine(string.Format("Sum: {0}, Count: {1})", valueTuple.Item1, valueTuple.Item2));
}

请注意，当我们调试我们的应用程序时，编译器仍然必须(通过属性)发生一些神奇的事情，因为看到 Item1、Item2 会很奇怪.

Note that the compiler still has to make some magic happen (via the attribute) when we debug our application, as it would be odd to see Item1, Item2.

这篇关于System.ValueTuple 和 System.Tuple 有什么区别?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！