Que sont ValueTupleset pourquoi pas à la Tupleplace?
A ValueTupleest une structure qui reflète un tuple, identique à la System.Tupleclasse d' origine .
La principale différence entre Tupleet ValueTuplesont:
System.ValueTupleest un type valeur (struct), tandis que System.Tupleest un type référence ( class). C'est significatif quand on parle d'allocations et de pression du GC.System.ValueTuplen'est pas seulement un struct, c'est un mutable , et il faut être prudent lorsqu'on les utilise comme tels. Pensez à ce qui se passe lorsqu'une classe détient un System.ValueTuplecomme champ.System.ValueTuple expose ses éléments via des champs au lieu de propriétés.
Jusqu'à C # 7, l'utilisation de tuples n'était pas très pratique. Leurs noms de champs sont Item1, Item2, etc., et la langue n'a pas fourni de sucre de syntaxe pour eux comme la plupart d' autres langages (Python, Scala).
Lorsque l'équipe de conception du langage .NET a décidé d'incorporer des tuples et de leur ajouter du sucre de syntaxe au niveau du langage, un facteur important était la performance. En ValueTupleétant un type valeur, vous pouvez éviter la pression du GC lors de leur utilisation car (en tant que détail d'implémentation) ils seront alloués sur la pile.
De plus, a structobtient une sémantique d'égalité automatique (superficielle) par le runtime, alors que a classne le fait pas. Bien que l'équipe de conception se soit assurée qu'il y aurait une égalité encore plus optimisée pour les tuples, elle a donc implémenté une égalité personnalisée.
Voici un paragraphe des notes de conception deTuples :
Struct ou Classe:
Comme mentionné, je propose de créer des types de tuple structsplutôt que
classes, de sorte qu'aucune pénalité d'allocation ne leur soit associée. Ils doivent être aussi légers que possible.
On structspeut soutenir que cela peut finir par être plus coûteux, car l'affectation copie une plus grande valeur. Donc, si on leur attribue beaucoup plus qu'ils ne sont créés, ce structsserait un mauvais choix.
Dans leur motivation même, les tuples sont éphémères. Vous les utiliseriez lorsque les parties sont plus importantes que le tout. Le modèle commun serait donc de les construire, de les restituer et de les déconstruire immédiatement. Dans cette situation, les structures sont clairement préférables.
Les structures présentent également un certain nombre d'autres avantages, qui deviendront évidents par la suite.
Exemples:
Vous pouvez facilement voir que travailler avec System.Tupledevient très rapidement ambigu. Par exemple, disons que nous avons une méthode qui calcule une somme et un compte de 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);
}
Du côté de la réception, nous nous retrouvons avec:
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);
La façon dont vous pouvez déconstruire les tuples de valeur en arguments nommés est la vraie puissance de la fonctionnalité:
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;
}
Et à la réception:
var result = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {result.Sum}, Count: {result.Count}");
Ou:
var (sum, count) = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {sum}, Count: {count}");
Goodies du compilateur:
Si nous regardons sous le couvert de notre exemple précédent, nous pouvons voir exactement comment le compilateur interprète ValueTuplelorsque nous lui demandons de déconstruire:
[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;
}
En interne, le code compilé utilise Item1et Item2, mais tout cela nous est abstrait puisque nous travaillons avec un tuple décomposé. Un tuple avec des arguments nommés est annoté avec le TupleElementNamesAttribute. Si nous utilisons une seule variable fraîche au lieu de la décomposer, nous obtenons:
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));
}
Notez que le compilateur doit encore faire quelque chose de magique se produit (via l'attribut) lorsque nous déboguer notre application, car il serait étrange de voir Item1, Item2.