Что есть ValueTuplesи почему нет Tuple?
A ValueTupleявляется структурой, которая отражает кортеж, такой же, как исходный System.Tupleкласс.
Основным отличием между Tupleи ValueTupleявляются:
System.ValueTupleтип значения (структура), а System.Tupleссылочный тип ( class). Это имеет смысл, когда речь идет о распределении ресурсов и давлении GC.System.ValueTupleэто не только struct, это изменчивый один, и один должен быть осторожным при использовании их в качестве таковых. Подумайте, что происходит, когда класс содержит System.ValueTupleполе.System.ValueTuple выставляет свои элементы через поля вместо свойств.
До C # 7 использование кортежей было не очень удобно. Их имена полейItem1 , Item2и т.д., и язык не поставляется синтаксис для них , как и большинства других языков делать (Python, Scala).
Когда команда разработчиков языка .NET решила включить кортежи и добавить к ним синтаксический сахар на уровне языка, важным фактором была производительность. С участиемValueTuple того типа значения, вы можете избежать давления ГХ при их использовании , потому что (как деталь реализации) они будут выделены в стеке.
Кроме того, a structполучает автоматическую (поверхностную) семантику равенства во время выполнения, гдеclass - нет. Хотя команда разработчиков позаботилась о том, чтобы для кортежей было еще более оптимизированное равенство, следовательно, реализовала собственное равенство для него.
Вот параграф из заметок о дизайнеTuples :
Структура или класс:
Как уже упоминалось, я предлагаю создавать типы кортежей, structsа не
classes, чтобы с ними не связывалось наказание за распределение. Они должны быть максимально легкими.
Возможно, structsможет оказаться более дорогостоящим, потому что назначение копирует большее значение. Поэтому, если им назначено намного больше, чем они созданы, то structsэто будет плохой выбор.
Однако по самой своей мотивации кортежи эфемерны. Вы бы использовали их, когда части важнее целого. Таким образом, общей схемой будет создание, возврат и немедленная деконструкция. В этой ситуации структуры явно предпочтительнее.
Структуры также имеют ряд других преимуществ, которые станут очевидными в следующем.
Примеры:
Вы можете легко увидеть, что работа с System.Tupleочень быстро становится неоднозначной. Например, скажем, у нас есть метод, который вычисляет сумму и количество 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);
}
На приемном конце мы получаем:
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);
Способ, которым вы можете деконструировать кортежи значений в именованные аргументы, является реальной силой функции:
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. Если вместо разложения мы используем одну свежую переменную, мы получим:
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.