Tuple Classe

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
Tuple.cs
Source:
Tuple.cs
Source:
Tuple.cs

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
Object
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 et une séquence spécifiques d’éléments. Un exemple de tuple est une structure de données avec trois éléments (appelés trois tuples ou triples) qui est utilisée 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 éléments ou plus 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 ensemble unique 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 fournir un accès facile à un jeu de données et la manipulation de ce jeu de données.

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

  • Pour passer 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 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 .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 peut être fastidieux. L’exemple suivant utilise un constructeur de classe pour créer un septuple ou un septuple à 7 tuples qui contient des données de population pour la ville de New York 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 le montre 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 tuple qui ont de un à huit composants (c’est-à-dire des singletons via des 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 de tuples individuels dans le .NET Framework. Celles-ci sont répertoriées dans la section Voir aussi à 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