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

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente un n-tuple, où n est supérieur ou égal à 8.

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TRest>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TRest>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple

public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

[System.Serializable]
public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7, TRest)
Implements IComparable, IStructuralComparable, IStructuralEquatable

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7, TRest)
Implements IComparable, IStructuralComparable, IStructuralEquatable, ITuple

Paramètres de type

T1

Type du premier composant du tuple.

T2

Type du second composant du tuple.

T3

Type du troisième composant du tuple.

T4

Type du quatrième composant du tuple.

T5

Type du cinquième composant du tuple.

T6

Type du sixième composant du tuple.

T7

Type du septième composant du tuple.

TRest

Tout objet Tuple générique qui définit les types des composants restants du tuple.

Héritage: Object
Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

Attributs: SerializableAttribute

Implémente: IStructuralComparable IStructuralEquatable IComparable ITuple

Remarques

Un tuple est une structure de données qui a un nombre et une séquence de valeurs spécifiques. La Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe représente un n-tuple qui a huit composants ou plus.

Vous pouvez instancier un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet avec exactement huit composants en appelant la méthode statique Tuple.Create . L’exemple suivant crée un 8-tuple (octuple) qui contient des nombres premiers inférieurs à 20. Notez qu’il utilise l’inférence de type pour déterminer le type de chaque composant.

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

Vous pouvez également instancier un objet n-tuple avec huit composants ou plus en appelant le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur. L’exemple suivant utilise le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur pour créer un tuple à 8 qui équivaut au tuple créé dans l’exemple précédent.

var primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
             Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19));

let primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
               Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19))

Dim primes = New Tuple(Of Int32, Int32, Int32, Int32, Int32, Int32, Int32, _ 
             Tuple(Of Int32))(2, 3, 5, 7, 11, 13, 17, New Tuple(Of Int32)(19))

Notes

Pour créer un n-tuple avec neuf composants ou plus, vous devez appeler le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur. Les méthodes de fabrique statique de la Tuple classe ne prennent pas en charge la création d’objets avec plus de Tuple huit composants.

Pour instancier un n-tuple qui a huit composants ou plus avec le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur, vous fournissez un objet générique Tuple comme rest paramètre pour définir les huitième à nième composants du tuple. En imbrication d’objets génériques Tuple de cette façon, vous pouvez créer un tuple qui n’a aucune limitation pratique sur le nombre de ses composants.

L’exemple suivant crée un tuple de 17 tuples qui contient des données de population pour la ville de Detroit, au Michigan, pour chaque recensement national de 1860 à 2000. Le premier composant du tuple est le nom de la ville. Le deuxième composant est la date de début de la série de données, et le troisième composant est la population à la date de début. Chaque composant suivant fournit la population à intervalles de dix ans. Le tuple 17 est créé en imbrication d’un Tuple<T1,T2,T3> objet à l’intérieur d’un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet. (Autrement dit, l’objet Tuple<T1,T2,T3> est fourni en tant que valeur du rest paramètre dans le constructeur de Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe.) Cet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet est, à son tour, imbriqué dans un objet externe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . (Autrement dit, l’objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> est fourni comme valeur du rest paramètre dans le constructeur de classe de l’objet externe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .)

var from1980 = Tuple.Create(1203339, 1027974, 951270);
var from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>> 
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980);
var population = new Tuple<string, int, int, int, int, int, int,
    Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>> 
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910);

let from1980 = Tuple.Create(1203339, 1027974, 951270)
let from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>(465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
let population = new Tuple<string, int, int, int, int, int, int, Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>>("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Dim from1980 = Tuple.Create(1203339, 1027974, 951270)
Dim from1910 As New Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, _
    Tuple(Of Integer, Integer, Integer)) _
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer, _ 
    Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, Tuple(Of Integer, Integer, Integer))) _
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Vous pouvez récupérer la valeur des sept premiers composants du tuple à l’aide des propriétés en lecture seule Item1, , Item2 Item3, Item4, Item6 Item5, et Item7 de l’instance. Tous les composants supplémentaires sont imbriqués et peuvent être récupérés à partir de la Rest propriété . Dans l’exemple précédent, les Item1 propriétés via Item7 récupèrent les premiers à septième composants du tuple. Les huit à quatorzième composants sont contenus dans le tuple imbriqué au deuxième niveau et sont représentés par les Rest.Item1 propriétés through Rest.Item7 . Les quinzième à dix-septième composants sont contenus dans le tuple imbriqué au troisième niveau, et sont représentés par les Rest.Rest.Item1 propriétés si Rest.Rest.Item3 .

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

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 de out paramètres (en C#) ou ByRef de paramètres (en Visual Basic). Par exemple, l’exemple précédent retourne ses statistiques calculées, ainsi que le nom de la ville, dans un Tuple<T1,T2,T3,T4,T5,T6,T7> objet.
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,T4,T5,T6,T7> objet comme argument de méthode, vous pouvez fournir la routine de démarrage du thread avec sept éléments de données.

Constructeurs

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

Initialise une nouvelle instance de la classe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Propriétés

Item1	Obtient la valeur du premier composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item2	Obtient la valeur du deuxième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item3	Obtient la valeur du troisième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item4	Obtient la valeur du quatrième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item5	Obtient la valeur du cinquième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item6	Obtient la valeur du sixième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Item7	Obtient la valeur du septième composant de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.
Rest	Obtient les composants restants de l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif.

Méthodes

Equals(Object)	Retourne une valeur qui indique si l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actuel est égal à un objet spécifié.
GetHashCode()	Calcule le code de hachage pour l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 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,T3,T4,T5,T6,T7,TRest>.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)	Compare l’objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 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,T3,T4,T5,T6,T7,TRest> 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 se trouve à 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,T3,T4,T5,T6,T7,TRest> 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,T3,T4,T5,T6,T7,TRest> 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`.

S’applique à