Was sind ValueTuplesund warum nicht Tuplestattdessen?
A ValueTupleist eine Struktur, die ein Tupel widerspiegelt, genau wie die ursprüngliche System.TupleKlasse.
Der Hauptunterschied zwischen Tupleund ValueTuplesind:
System.ValueTupleist ein Werttyp (struct), während System.Tuplees sich um einen Referenztyp ( class) handelt. Dies ist sinnvoll, wenn es um Zuweisungen und GC-Druck geht.System.ValueTupleist nicht nur eine struct, es ist eine veränderliche , und man muss vorsichtig sein, wenn man sie als solche verwendet. Überlegen Sie, was passiert, wenn eine Klasse System.ValueTupleein Feld enthält.System.ValueTuple macht seine Elemente über Felder anstelle von Eigenschaften verfügbar.
Bis C # 7 war die Verwendung von Tupeln nicht sehr praktisch. Ihre Feldnamen sind Item1, Item2usw., und die Sprache noch nicht geliefert Syntax Zucker für sie wie die meisten anderen Sprachen tun (Python, Scala).
Als das .NET-Sprachdesign-Team beschloss, Tupel zu integrieren und ihnen auf Sprachebene Syntaxzucker hinzuzufügen, war die Leistung ein wichtiger Faktor. Da ValueTuplees sich um einen Wertetyp handelt, können Sie GC-Druck vermeiden, wenn Sie sie verwenden, da sie (als Implementierungsdetail) auf dem Stapel zugewiesen werden.
Zusätzlich structerhält a zur Laufzeit eine automatische (flache) Gleichheitssemantik, wo a classdies nicht tut. Obwohl das Designteam dafür gesorgt hat, dass es eine noch optimierte Gleichheit für Tupel gibt, wurde daher eine benutzerdefinierte Gleichheit für Tupel implementiert.
Hier ist ein Absatz aus den Design Notes vonTuples :
Struktur oder Klasse:
Wie bereits erwähnt, schlage ich vor, Tupeltypen structsanstelle von zu erstellen
classes, damit mit ihnen keine Zuordnungsstrafe verbunden ist. Sie sollten so leicht wie möglich sein.
structsKann möglicherweise teurer werden, da die Zuweisung einen größeren Wert kopiert. Wenn ihnen also viel mehr zugewiesen wird als sie erstellt werden, structswäre dies eine schlechte Wahl.
In ihrer Motivation sind Tupel jedoch vergänglich. Sie würden sie verwenden, wenn die Teile wichtiger sind als das Ganze. Das übliche Muster wäre also, sie zu konstruieren, zurückzugeben und sofort zu dekonstruieren. In dieser Situation sind Strukturen eindeutig vorzuziehen.
Strukturen haben auch eine Reihe anderer Vorteile, die im Folgenden deutlich werden.
Beispiele:
Sie können leicht erkennen, dass das Arbeiten mit System.Tuplesehr schnell mehrdeutig wird. Angenommen, wir haben eine Methode, die eine Summe und eine Anzahl von a berechnet 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);
}
Am empfangenden Ende erhalten wir:
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);
Die Art und Weise, wie Sie Wertetupel in benannte Argumente zerlegen können, ist die eigentliche Stärke der Funktion:
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;
}
Und auf der Empfangsseite:
var result = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {result.Sum}, Count: {result.Count}");
Oder:
var (sum, count) = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {sum}, Count: {count}");
Compiler-Goodies:
Wenn wir uns das Cover unseres vorherigen Beispiels ansehen, können wir genau sehen, wie der Compiler interpretiert, ValueTuplewenn wir ihn zum Dekonstruieren auffordern:
[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;
}
Intern verwendet der kompilierte Code Item1und Item2, aber all dies wird von uns abstrahiert, da wir mit einem zerlegten Tupel arbeiten. Ein Tupel mit benannten Argumenten wird mit dem versehen TupleElementNamesAttribute. Wenn wir eine einzelne neue Variable verwenden, anstatt sie zu zerlegen, erhalten wir:
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));
}
Beachten Sie, dass der Compiler muss noch etwas Magie (über das Attribut) geschehen , wenn wir unsere Anwendung debuggen, wie es seltsam wäre , um zu sehen Item1, Item2.