Tuple Classe

Définition

Fournit des méthodes statiques pour la création d’objets tuple.

public ref class Tuple abstract sealed
public static class Tuple
type Tuple = class
Public Class Tuple
Héritage
Tuple

Exemples

L’exemple suivant crée un 8 tuple (octuple) qui contient des nombres premiers inférieurs à 20.

var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1);
// The example displays the following output:
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19
open System

let primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
printfn $"Prime numbers less than 20: {primes.Item1}, {primes.Item2}, {primes.Item3}, {primes.Item4}, {primes.Item5}, {primes.Item6}, {primes.Item7}, and {primes.Rest.Item1}"
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19
Dim primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1)
' The example displays the following output:
'     Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Remarques

Un tuple est une structure de données qui a un nombre spécifique et une séquence d’éléments. Un exemple de tuple est une structure de données avec trois éléments (appelés trois tuples ou triples) utilisés pour stocker un identificateur tel que le nom d’une personne dans le premier élément, une année dans le deuxième élément et le revenu de la personne pour cette année dans le troisième élément. Le .NET Framework prend directement en charge les tuples avec un à sept éléments. En outre, vous pouvez créer des tuples de huit ou plusieurs éléments en imbrication d’objets tuple dans la Rest propriété d’un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet.

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

  • Pour représenter un seul ensemble de données. Par exemple, un tuple peut représenter un enregistrement de base de données et ses composants peuvent représenter des champs individuels de l’enregistrement.

  • Pour faciliter l’accès et la manipulation d’un jeu de données.

  • Pour retourner plusieurs valeurs à partir d’une méthode sans utiliser out de paramètres (en C#) ou ByRef de paramètres (dans Visual Basic).

  • 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,T3> objet comme argument de méthode, vous pouvez fournir la routine de démarrage du thread avec trois éléments de données.

La Tuple classe ne représente pas elle-même un tuple. Au lieu de cela, il s’agit d’une classe qui fournit des méthodes statiques pour créer des instances des types tuple pris en charge par le .NET Framework. Il fournit des méthodes d’assistance que vous pouvez appeler pour instancier des objets tuple sans avoir à spécifier explicitement le type de chaque composant tuple.

Bien que vous puissiez créer une instance d’une classe tuple en appelant son constructeur de classe, le code à effectuer peut être fastidieux. L’exemple suivant utilise un constructeur de classe pour créer un 7 tuple ou septuple qui contient des données de population pour chaque recensement de 1950 à 2000.

// Create a 7-tuple.
var population = new Tuple<string, int, int, int, int, int, int>(
                           "New York", 7891957, 7781984, 
                           7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278
// Create a 7-tuple.
let population = Tuple<string, int, int, int, int, int, int>(
                            "New York", 7891957, 7781984, 
                            7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278
' Create a 7-tuple.
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer) _
                           ("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

La création du même objet tuple à l’aide d’une méthode d’assistance est plus simple, comme l’illustre l’exemple suivant.

// Create a 7-tuple.
var population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278
// Create a 7-tuple.
let population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278
' Create a 7-tuple.
Dim population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

Les Create méthodes d’assistance prennent directement en charge la création d’objets tuples qui ont d’un à huit composants (autrement dit, singletons via les octuples). Bien qu’il n’existe aucune limite pratique au nombre de composants qu’un tuple peut avoir, les méthodes d’assistance ne sont pas disponibles pour créer un tuple avec neuf composants ou plus. Pour créer un tel tuple, vous devez appeler le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur.

Notes

Pour plus d’informations et d’exemples qui utilisent des tuples, consultez la documentation relative aux types tuple individuels dans le .NET Framework. Celles-ci sont répertoriées dans la section Voir également à la fin de cette rubrique.

Méthodes

Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)

Crée un tuples à 8 composants, ou octuple.

Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)

Crée un tuples à 7 composants, ou septuple.

Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)

Crée un tuple à 6 composants, ou sextuple.

Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)

Crée un tuple à 5 composants, ou quintuple.

Create<T1,T2,T3,T4>(T1, T2, T3, T4)

Crée un tuple à 4 composants, ou quadruple.

Create<T1,T2,T3>(T1, T2, T3)

Crée un tuple à 3 composants, ou triple.

Create<T1,T2>(T1, T2)

Crée un tuple à 2 composants, ou paire.

Create<T1>(T1)

Crée un tuple à 1 composant, ou singleton.

S’applique à

Voir aussi