Quelle exigence le tuple a-t-il été conçu pour résoudre?

Je regarde la nouvelle fonctionnalité C # des tuples. Je suis curieux de savoir quel problème le tuple a-t-il été conçu pour résoudre?

Pourquoi avez-vous utilisé des tuples dans vos applications?

Mettre à jour

Merci pour les réponses jusqu'à présent, laissez-moi voir si j'ai des choses claires dans mon esprit. Un bon exemple de tuple a été indiqué comme coordonnées. Cela semble-t-il correct?

var coords = Tuple.Create(geoLat,geoLong);

Ensuite, utilisez le tuple comme ceci:

var myLatlng = new google.maps.LatLng("+ coords.Item1 + ", "+ coords.Item2 + ");

Est-ce exact?

Lors de l'écriture de programmes, il est extrêmement courant de vouloir regrouper logiquement un ensemble de valeurs qui n'ont pas suffisamment de points communs pour justifier la création d'une classe.

De nombreux langages de programmation vous permettent de regrouper logiquement un ensemble de valeurs autrement sans rapport sans créer de type d'une seule manière:

void M(int foo, string bar, double blah)

Logiquement, c'est exactement la même chose qu'une méthode M qui prend un argument qui est un 3-tuple de int, string, double. Mais j'espère que vous ne feriez pas réellement:

class MArguments
{
   public int Foo { get; private set; } 
   ... etc

à moins que MArguments ait une autre signification dans la logique métier.

Le concept de «regrouper un tas de données autrement sans rapport dans une structure plus légère qu'une classe» est utile dans de très nombreux endroits, pas seulement pour les listes de paramètres formelles de méthodes. C'est utile lorsqu'une méthode a deux choses à renvoyer, ou lorsque vous souhaitez saisir un dictionnaire de deux données plutôt qu'une, et ainsi de suite.

Les langages comme F # qui prennent en charge les types de tuple offrent nativement une grande flexibilité à leurs utilisateurs; ils constituent un ensemble extrêmement utile de types de données. L'équipe BCL a décidé de travailler avec l'équipe F # pour standardiser sur un type de tuple pour le framework afin que chaque langage puisse en bénéficier.

Cependant, il n'existe à ce stade aucune prise en charge du langage pour les tuples en C #. Les tuples ne sont qu'un autre type de données comme toute autre classe de framework; il n'y a rien de spécial à leur sujet. Nous envisageons d'ajouter un meilleur support pour les tuples dans les futures versions hypothétiques de C #. Si quelqu'un a des idées sur le type de fonctionnalités impliquant des tuples que vous aimeriez voir, je serais heureux de les transmettre à l'équipe de conception. Les scénarios réalistes sont plus convaincants que les réflexions théoriques.

Les tuples fournissent une implémentation immuable d'une collection

Outre les utilisations courantes des tuples:

• pour regrouper des valeurs communes sans avoir à créer de classe
• pour renvoyer plusieurs valeurs d'une fonction / méthode
• etc...

Les objets immuables sont intrinsèquement thread-safe:

Les objets immuables peuvent être utiles dans les applications multithreads. Plusieurs threads peuvent agir sur des données représentées par des objets immuables sans se soucier des données modifiées par d'autres threads. Les objets immuables sont donc considérés comme plus sûrs pour les threads que les objets mutables.

Depuis "Objet immuable" sur wikipedia

Il fournit une alternative à refou outsi vous avez une méthode qui doit renvoyer plusieurs nouveaux objets dans le cadre de sa réponse.

Il vous permet également d'utiliser un type intégré comme type de retour si tout ce que vous avez à faire est de combiner deux ou trois types existants et que vous ne voulez pas avoir à ajouter une classe / structure juste pour cette combinaison. (Avez-vous déjà souhaité qu'une fonction renvoie un type anonyme? C'est une réponse partielle à cette situation.)

Il est souvent utile d'avoir un type "paire", juste utilisé dans des situations rapides (comme retourner deux valeurs d'une méthode). Les tuples sont une partie centrale des langages fonctionnels comme F #, et C # les a repris en cours de route.

très utile pour renvoyer deux valeurs à partir d'une fonction

Personnellement, je trouve que Tuples est une partie itérative du développement lorsque vous êtes dans un cycle d'investigation ou que vous "jouez". Parce qu'un Tuple est générique, j'ai tendance à y penser lorsque je travaille avec des paramètres génériques - en particulier lorsque je veux développer un morceau de code générique, et je commence par la fin du code, au lieu de me demander "comment j'aimerais cet appel regarder?".

Très souvent, je me rends compte que la collection que les formes Tuple font partie d'une liste, et regarder List> n'exprime pas vraiment l'intention de la liste, ni comment elle fonctionne. Je "vis" souvent avec, mais j'ai envie de manipuler la liste et de changer une valeur - à quel point, je ne veux pas nécessairement créer un nouveau Tuple pour cela, donc je dois créer ma propre classe ou structure pour le tenir, donc je peux ajouter du code de manipulation.

Bien sûr, il existe toujours des méthodes d'extension - mais bien souvent, vous ne voulez pas étendre ce code supplémentaire à des implémentations génériques.

Il y a eu des moments où je voulais exprimer des données sous forme de tuple, et je n'avais pas de tuples disponible. (VS2008) auquel cas je viens de créer ma propre classe Tuple - et je ne la rend pas thread-safe (immuable).

Je suppose donc que je suis d'avis que les tuples sont une programmation paresseuse au détriment de la perte d'un nom de type qui décrit son but. L'autre dépense est que vous devez déclarer la signature du Tuple partout où elle est utilisée comme paramètre. Après un certain nombre de méthodes qui commencent à paraître gonflées, vous pouvez ressentir comme moi qu'il vaut la peine de créer une classe, car elle nettoie les signatures de méthode.

J'ai tendance à commencer par avoir la classe en tant que membre public de la classe dans laquelle vous travaillez déjà. Mais au moment où elle s'étend au-delà d'une simple collection de valeurs, elle obtient son propre fichier, et je la déplace hors de la classe contenant.

Donc, rétrospectivement, je crois que j'utilise Tuples quand je ne veux pas aller écrire un cours, et que je veux juste penser à ce que j'écris en ce moment. Ce qui signifie que la signature du Tuple peut changer beaucoup dans le texte une demi-heure pendant que je détermine les données dont je vais avoir besoin pour cette méthode et comment elle renvoie les valeurs qu'elle renverra.

Si j'ai la chance de refactoriser le code, je remets souvent en question la place d'un Tuple dans celui-ci.

Ancienne question depuis 2010, et maintenant en 2017, Dotnet change et devient plus intelligent.

C # 7 introduit la prise en charge du langage pour les tuples, qui active les noms sémantiques pour les champs d'un tuple à l'aide de nouveaux types de tuple plus efficaces.

Dans vs 2017 et .Net 4.7 (ou en installant le package nuget System.ValueTuple), vous pouvez créer / utiliser un tuple de manière très efficace et simple:

     var person = (Id:"123", Name:"john"); //create tuble with two items
     Console.WriteLine($"{person.Id} name:{person.Name}") //access its fields

Renvoyer plusieurs valeurs d'une méthode:

    public (double sum, double average) ComputeSumAndAverage(List<double> list)
    {
       var sum= list.Sum();
        var average = sum/list.Count;
        return (sum, average);
    }

    How to use:

        var list=new List<double>{1,2,3};
        var result = ComputeSumAndAverage(list);
        Console.WriteLine($"Sum={result.sum} Average={result.average}");    

Pour plus de détails, lisez: https://docs.microsoft.com/en-us/dotnet/csharp/tuples

Un tuple est souvent utilisé pour renvoyer plusieurs valeurs à partir de fonctions lorsque vous ne souhaitez pas créer un type spécifique. Si vous êtes familier avec Python, Python a cela depuis longtemps.

Renvoyer plus d'une valeur à partir d'une fonction. getCoordinates () n'est pas très utile s'il renvoie simplement x, y ou z, mais créer une classe et un objet complets pour contenir trois entiers semble également assez lourd.

Une utilisation courante peut être d'éviter de créer des classes / structures qui ne contiennent que 2 champs, à la place vous créez un Tuple (ou un KeyValuePair pour le moment). Utile comme valeur de retour, évitez de passer N paramètres ...

Je trouve que KeyValuePair est actualisé en C # pour parcourir les paires clé / valeur dans un dictionnaire.

C'est vraiment utile pour renvoyer les valeurs des fonctions. Nous pouvons avoir plusieurs valeurs en retour et c'est tout à fait un économiseur dans certains scénarios.

Je suis tombé sur ce benchmark de performance entre les paires tuples et clé-valeur et vous le trouverez probablement intéressant. En résumé, il dit que Tuple a l'avantage parce que c'est une classe, donc il est stocké dans le tas et non dans la pile et lorsqu'il est passé en argument, son pointeur est la seule chose qui va. Mais KeyValuePair est une structure, donc il est plus rapide à allouer mais il est plus lent lorsqu'il est utilisé.

http://www.dotnetperls.com/tuple-keyvaluepair