Cosa sono ValueTuplese perché no Tupleinvece?
A ValueTupleè una struttura che riflette una tupla, uguale alla System.Tupleclasse originale .
Le principali differenze tra Tuplee ValueTuplesono:
System.ValueTupleè un tipo di valore (struct), mentre System.Tupleè un tipo di riferimento ( class). Ciò è significativo quando si parla di allocazioni e pressione GC.System.ValueTuplenon è solo un struct, è mutevole e bisogna stare attenti quando li si utilizza come tale. Pensa cosa succede quando una classe contiene System.ValueTupleun campo.System.ValueTuple espone i suoi elementi tramite campi anziché proprietà.
Fino a C # 7, usare le tuple non era molto conveniente. I loro nomi dei campi sono Item1, Item2ecc., E la lingua non aveva fornito zucchero di sintassi per loro come la maggior parte delle altre lingue (Python, Scala).
Quando il team di progettazione del linguaggio .NET ha deciso di incorporare le tuple e aggiungere zucchero di sintassi a livello linguistico, un fattore importante sono state le prestazioni. Con ValueTupleessendo un tipo di valore, si può evitare la pressione GC quando li utilizzano perché (come un dettaglio di implementazione) essi saranno attribuiti sulla pila.
Inoltre, a structottiene la semantica di uguaglianza automatica (superficiale) dal runtime, dove a classno. Sebbene il team di progettazione si sia assicurato che ci sarà un'uguaglianza ancora più ottimizzata per le tuple, quindi ha implementato un'uguaglianza personalizzata per essa.
Ecco un paragrafo dalle note di progettazione diTuples :
Struct o Class:
Come accennato, propongo di creare tipi di tupla structspiuttosto che
classes, in modo che non sia associata alcuna penalità di allocazione. Dovrebbero essere il più leggeri possibile.
Probabilmente, structspuò finire per essere più costoso, perché l'assegnazione copia un valore maggiore. Quindi, se vengono assegnati molto più di quanto vengano creati, structssarebbe una cattiva scelta.
Nella loro stessa motivazione, tuttavia, le tuple sono effimere. Li useresti quando le parti sono più importanti del tutto. Quindi lo schema comune sarebbe quello di costruirli, restituirli e decostruirli immediatamente. In questa situazione le strutture sono chiaramente preferibili.
Le strutture hanno anche una serie di altri vantaggi, che diventeranno evidenti di seguito.
Esempi:
Si può facilmente vedere che lavorare con System.Tuplediventa ambiguo molto rapidamente. Ad esempio, supponiamo di avere un metodo che calcola una somma e un conteggio di un 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);
}
Alla fine della ricezione, finiamo con:
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);
Il modo in cui puoi decostruire le tuple di valore in argomenti con nome è il vero potere della funzione:
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;
}
E alla fine di ricezione:
var result = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {result.Sum}, Count: {result.Count}");
O:
var (sum, count) = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {sum}, Count: {count}");
Chicche del compilatore:
Se guardiamo sotto la copertina del nostro esempio precedente, possiamo vedere esattamente come il compilatore sta interpretando ValueTuplequando gli chiediamo di decostruire:
[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;
}
Internamente, il codice compilato utilizza Item1e Item2, ma tutto questo viene sottratto a noi poiché lavoriamo con una tupla decomposta. Una tupla con argomenti denominati viene annotata con TupleElementNamesAttribute. Se utilizziamo una singola variabile nuova invece di decomporre, otteniamo:
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));
}
Si noti che il compilatore deve ancora fare accadere qualche magia (tramite l'attributo) quando si esegue il debug la nostra applicazione, in quanto sarebbe strano vedere Item1, Item2.