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

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

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.

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

public:
 Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);

public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);

new Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'Rest -> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest>

Public Sub New (item1 As T1, item2 As T2, item3 As T3, item4 As T4, item5 As T5, item6 As T6, item7 As T7, rest As TRest)

Paramètres

item1: T1

Valeur du premier composant du tuple.

item2: T2

Valeur du second composant du tuple.

item3: T3

Valeur du troisième composant du tuple.

item4: T4

Valeur du quatrième composant du tuple.

item5: T5

Valeur du cinquième composant du tuple.

item6: T6

Valeur du sixième composant du tuple.

item7: T7

Valeur du septième composant du tuple.

rest: TRest

Tout objet Tuple générique qui contient les valeurs des composants restants du tuple.

Exceptions

ArgumentException

rest n'est pas un objet Tuple générique.

Exemples

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 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. L’exemple utilise deux couches d’imbrication pour créer le tuple à 17 : il définit un 7-tuple dont les troisième à septième composants contiennent des données de population pour 1860 à 1900, un 7 tuple imbriqué qui contient des données de population pour 1910 à 1970, et un 3-tuple imbriqué interne qui contient des données de population pour 1980 à 2000.

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)

Remarques

Vous pouvez également utiliser la méthode statique Tuple.Create pour instancier un objet à 8 tuples (octuple) sans avoir à spécifier explicitement les types de ses composants. L’exemple suivant utilise la Tuple.Create méthode pour instancier un objet à 8 tuples 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

Cela équivaut à l’appel suivant au constructeur de Tuple<T1,T2,T3,T4,T5,T6,T7> classe.

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))

Toutefois, la méthode statique Tuple.Create ne peut pas être utilisée pour créer un objet tuple avec plus de huit composants.

Lorsque vous utilisez le Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructeur pour créer un n-tuple avec huit composants ou plus, vous utilisez le rest paramètre pour créer un n-tuple imbriqué qui comporte de un à sept composants. En utilisant des niveaux d’imbrication successifs, vous pouvez créer un n-tuple qui a un nombre pratiquement illimité de composants. Par exemple, pour créer un tuple à 25 tuples, vous instanciez un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet avec trois niveaux d’imbrication, comme suit :

L’objet le plus externe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> contient les premiers à septième composants. Sa Rest propriété permet d’accéder à un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet au premier niveau d’imbrication.
L’objet imbriqué Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> le plus externe contient les composants huitième à quatorzième, et sa Rest propriété permet d’accéder à un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objet au deuxième niveau d’imbrication.
L’objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> au deuxième niveau d’imbrication contient les composants quinzième à vingt et unième, et sa Rest propriété fournit l’accès à un Tuple<T1,T2,T3,T4> objet au troisième niveau d’imbrication.
Le tuple le plus interne est un Tuple<T1,T2,T3,T4> objet qui contient les vingt-secondes à vingt-cinquième composants.

S’applique à

Voir aussi

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

Partager via