Tuple<T1,T2> Classe

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Représente un objet de 2 tuples, ou paire.

C#

public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

C#

public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

C#

[System.Serializable]
public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

Paramètres de type

T1

Type du premier composant du tuple.

T2

Type du second composant du tuple.

Héritage

Object

Tuple<T1,T2>

Attributs

SerializableAttribute

Implémente

IStructuralComparable IStructuralEquatable IComparable ITuple

Remarques

Un tuple est une structure de données qui a un nombre spécifique et une séquence de valeurs. La Tuple<T1,T2> classe représente un tuple de 2 tuples ou une paire, qui est un tuple qui a deux composants. Un tuple de 2 tuples est similaire à une KeyValuePair<TKey,TValue> structure.

Vous pouvez instancier un Tuple<T1,T2> objet en appelant le Tuple<T1,T2> constructeur ou la méthode statique Tuple.Create<T1,T2>(T1, T2) . Vous pouvez récupérer les valeurs des composants du tuple à l’aide des propriétés de lecture seule Item1 et Item2 d’instance.

Les tuples sont couramment utilisés de quatre façons différentes :

• Pour représenter un seul ensemble de données. Par exemple, un tuple peut représenter un enregistrement dans une base de données et ses composants peuvent représenter les champs de cet enregistrement.

• Pour faciliter l’accès et la manipulation d’un jeu de données. L’exemple suivant définit un tableau d’objets Tuple<T1,T2> qui contiennent les noms des étudiants et leurs scores de test correspondants. Il itère ensuite le tableau pour calculer le score de test moyen.

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Tuple<string, Nullable<int>>[] scores = 
                      { new Tuple<string, Nullable<int>>("Jack", 78),
                        new Tuple<string, Nullable<int>>("Abbey", 92), 
                        new Tuple<string, Nullable<int>>("Dave", 88),
                        new Tuple<string, Nullable<int>>("Sam", 91), 
                        new Tuple<string, Nullable<int>>("Ed", null),
                        new Tuple<string, Nullable<int>>("Penelope", 82),
                        new Tuple<string, Nullable<int>>("Linda", 99),
                        new Tuple<string, Nullable<int>>("Judith", 84) };
        int number;
        double mean = ComputeMean(scores, out number);
        Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number);
     }
  
     private static double ComputeMean(Tuple<string, Nullable<int>>[] scores, out int n) 
     {
        n = 0;      
        int sum = 0;
        foreach (var score in scores)
        {
           if (score.Item2.HasValue)
           { 
              n += 1;
              sum += score.Item2.Value;
           }
        }     
        if (n > 0)
           return sum / (double) n;
        else
           return 0;
     }
  }
  // The example displays the following output:
  //       Average test score: 87.71 (n=7)
  

• Pour renvoyer plusieurs valeurs à partir d’une méthode sans utiliser de out paramètres (en C#) ou ByRef de paramètres (dans Visual Basic). Par exemple, l’exemple suivant utilise un Tuple<T1,T2> objet pour renvoyer le quotient et le reste résultant de la division entière.

  C#

  using System;
  
  public class Class1
  {
     public static void Main()
     {
        int dividend, divisor;
        Tuple<int, int> result;
        
        dividend = 136945; divisor = 178;
        result = IntegerDivide(dividend, divisor);
        if (result != null)
           Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                             dividend, divisor, result.Item1, result.Item2);
        else
           Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
                          
        dividend = Int32.MaxValue; divisor = -2073;
        result = IntegerDivide(dividend, divisor);
        if (result != null)
           Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                             dividend, divisor, result.Item1, result.Item2);
        else
           Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
     }
  
     private static Tuple<int, int> IntegerDivide(int dividend, int divisor)
     {
        try {
           int remainder;
           int quotient = Math.DivRem(dividend, divisor, out remainder);
           return new Tuple<int, int>(quotient, remainder);
        }   
        catch (DivideByZeroException) {
           return null;
        }      
     }
  }
  // The example displays the following output:
  //       136945 \ 178 = 769, remainder 63
  //       2147483647 \ -2073 = -1035930, remainder 757
  

• Pour transmettre plusieurs valeurs à une méthode via un seul paramètre. Par exemple, la Thread.Start(Object) méthode a un seul paramètre qui vous permet de fournir une valeur à la méthode que le thread s’exécute au démarrage. Si vous fournissez un Tuple<T1,T2> objet comme argument de méthode, vous pouvez fournir la routine de démarrage du thread avec deux éléments de données.

Constructeurs

Tuple<T1,T2>(T1, T2)

Initialise une nouvelle instance de la classe Tuple<T1,T2>.

Propriétés

Item1	Obtient la valeur du premier composant de l'objet Tuple<T1,T2> actif.
Item2	Obtient la valeur du deuxième composant de l'objet Tuple<T1,T2> actif.

Méthodes

Equals(Object)	Retourne une valeur qui indique si l'objet Tuple<T1,T2> actuel est égal à un objet spécifié.
GetHashCode()	Retourne le code de hachage pour l'objet Tuple<T1,T2> actuel.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente la valeur de cette instance Tuple<T1,T2>.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)	Compare l’objet Tuple<T1,T2> actuel à un objet spécifié et renvoie un entier qui indique si l’objet actuel est avant, après ou à la même position que l’objet spécifié dans l’ordre de tri.
IStructuralComparable.CompareTo(Object, IComparer)	Compare l'objet Tuple<T1,T2> actif à un objet spécifié à l'aide d'un comparateur spécifié et retourne un entier qui indique si l'objet actif précède, suit ou est dans la même position que l'objet spécifié dans l'ordre de tri.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Retourne une valeur qui indique si l'objet Tuple<T1,T2> actif est égal à un objet spécifié selon une méthode de comparaison spécifiée.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Calcule le code de hachage pour l'objet Tuple<T1,T2> actif à l'aide d'une méthode de calcul spécifiée.
ITuple.Item[Int32]	Obtient la valeur de l’élément Tuple spécifié.
ITuple.Length	Obtient le nombre d’éléments dans Tuple.

Méthodes d’extension

Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)	Décompose un tuple avec 2 éléments dans des variables distinctes.
ToValueTuple<T1,T2>(Tuple<T1,T2>)	Convertit une instance de la classe Tuple en une instance de la structure ValueTuple.

S’applique à

Voir aussi

• Tuple
• Tuple<T1>
• Tuple<T1,T2,T3>
• Tuple<T1,T2,T3,T4>
• Tuple<T1,T2,T3,T4,T5>
• Tuple<T1,T2,T3,T4,T5,T6>
• Tuple<T1,T2,T3,T4,T5,T6,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>