Partager via

Tuple Classe

Définition

Espace de noms:
System
Assemblys:
mscorlib.dll, System.Runtime.dll
Assemblys:
netstandard.dll, System.Runtime.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
Tuple.cs
Source:
Tuple.cs
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 tuple de 8 tuples (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) 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 éléments ou plus en imbrication d’objets tuples 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 faciliter l’accès et la manipulation d’un 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 paramètre unique qui vous permet de fournir une valeur à la méthode exécutée par le thread au moment du 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 à faire 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 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 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 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.

Note

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

Méthodes

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

Crée un nouveau tuple de 8 tuples ou octuple.
Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)

Crée un nouveau tuple de 7 tuples ou septuple.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)

Crée un nouveau tuple à 6 tuples ou sextuple.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)

Crée un nouveau tuple de 5 tuples ou un quintuple.
Create<T1,T2,T3,T4>(T1, T2, T3, T4)

Crée un nouveau tuple 4 tuples ou quadruplé.
Create<T1,T2,T3>(T1, T2, T3)

Crée un nouveau tuple à 3 tuples ou triple.
Create<T1,T2>(T1, T2)

Crée un nouveau tuple ou une paire de 2 tuples.
Create<T1>(T1)

Crée un nouveau tuple 1 tuple ou singleton.

S’applique à

Voir aussi