Tuple<T1,T2,T3,T4,T5,T6,T7> 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 objet de 7 tuples, ou septuple.

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
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>
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> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

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

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

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

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

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

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

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

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7)
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.

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

Attributs: SerializableAttribute

Implémente: IStructuralComparable IStructuralEquatable IComparable ITuple

Remarques

Un tuple est une structure de données qui a un nombre spécifique et une séquence de valeurs. La Tuple<T1,T2,T3,T4,T5,T6,T7> classe représente un 7 tuples ou un septuple, qui est un tuple qui a sept composants.

Vous pouvez instancier un Tuple<T1,T2,T3,T4,T5,T6,T7> objet en appelant soit la Tuple<T1,T2,T3,T4,T5,T6,T7> méthode statique Tuple.Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7) . Vous pouvez récupérer la valeur des composants du tuple à l’aide des propriétés en lecture seuleItem1, , Item3 Item2, Item4, Item5et Item6 Item7 des propriétés d’instance.

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

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. L’exemple suivant définit un Tuple<T1,T2,T3,T4,T5,T6,T7> objet qui contient des données de population pour New York pour chaque recensement de 1950 à 2000. La septuple est passée à la ComputePopulationChange méthode, qui calcule le taux annuel de changement entre les recensements, ainsi que le taux annuel de changement pour l’ensemble de la période de 60 ans.

using System;

public class Example
{
   public static void Main()
   {
      // Get population data for New York City, 1950-2000.
      var population = Tuple.Create("New York", 7891957, 7781984, 
                                    7894862, 7071639, 7322564, 8008278);
      var rate = ComputePopulationChange(population);
      // Display results.
      Console.WriteLine("Population Change, {0}, 1950-2000\n", population.Item1);
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
      Console.WriteLine("1950      {0,10:N0} {1,11}", population.Item2, "NA");
      Console.WriteLine("1960      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item7, rate.Item6/10);
      Console.WriteLine("1950-2000 {0,10:N0} {1,11:P2}", "", rate.Item7/50);
   }

   private static Tuple<string, double, double, double, double, double, double> 
        ComputePopulationChange(
           Tuple<string, int, int, int, int, int, int> data)  
   {           
      var rate = Tuple.Create(data.Item1, 
                       (double)(data.Item3 - data.Item2)/data.Item2, 
                       (double)(data.Item4 - data.Item3)/data.Item3, 
                       (double)(data.Item5 - data.Item4)/data.Item4, 
                       (double)(data.Item6 - data.Item5)/data.Item5,
                       (double)(data.Item7 - data.Item6)/data.Item6,
                       (double)(data.Item7 - data.Item2)/data.Item2 );
      return rate;
   }           
}
// The example displays the following output:
//       Population Change, New York, 1950-2000
//       
//       Year      Population Annual Rate
//       1950       7,891,957          NA
//       1960       7,781,984     -0.14 %
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1950-2000                 0.03 %

open System

let computePopulationChange (data: Tuple<string, int, int, int, int, int, int>) =  
    Tuple.Create(data.Item1, 
                 double (data.Item3 - data.Item2) / double data.Item2, 
                 double (data.Item4 - data.Item3) / double data.Item3, 
                 double (data.Item5 - data.Item4) / double data.Item4, 
                 double (data.Item6 - data.Item5) / double data.Item5,
                 double (data.Item7 - data.Item6) / double data.Item6,
                 double (data.Item7 - data.Item2) / double data.Item2)

// Get population data for New York City, 1950-2000.
let population = 
    Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
let rate = computePopulationChange population
// Display results.
printfn $"Population Change, {population.Item1}, 1950-2000\n"
printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
printfn $"""1950      {population.Item2,10:N0} {"NA",11}"""
printfn $"1960      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
printfn $"1970      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}" 
printfn $"1980      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}" 
printfn $"1990      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}" 
printfn $"2000      {population.Item7,10:N0} {rate.Item6 / 10.,11:P2}" 
printfn $"""1950-2000 {"",10:N0} {rate.Item7 / 50.,11:P2}"""

// The example displays the following output:
//       Population Change, New York, 1950-2000
//       
//       Year      Population Annual Rate
//       1950       7,891,957          NA
//       1960       7,781,984     -0.14 %
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1950-2000                 0.03 %

Module Example
   Public Sub Main()
      ' Get population data for New York City, 1950-2000.
      Dim population = Tuple.Create("New York", 7891957, 7781984, 
                                    7894862, 7071639, 7322564, 8008278)
      Dim rate = ComputePopulationChange(population)      
      ' Display results.
      Console.WriteLine("Population Change, {0}, 1950-2000", population.Item1)
      Console.WriteLine()
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
      Console.WriteLine("1950      {0,10:N0} {1,11}", population.Item2, "NA")
      Console.WriteLine("1960      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item7, rate.Item6/10)
      Console.WriteLine("1950-2000 {0,10:N0} {1,11:P2}", "", rate.Item7/50)
   End Sub
   
      ' Compute rate of population change by decade and overall.
   Private Function ComputePopulationChange(data As Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer)) _ 
           As Tuple(Of String, Double, Double, Double, Double, Double, Double)
      Dim rate = Tuple.Create( data.Item1, 
                       (data.Item3 - data.Item2)/data.Item2, 
                       (data.Item4 - data.Item3)/data.Item3, 
                       (data.Item5 - data.Item4)/data.Item4, 
                       (data.Item6 - data.Item5)/data.Item5,
                       (data.Item7 - data.Item6)/data.Item6,
                       (data.Item7 - data.Item2)/data.Item2 )
      Return rate
   End Function           
End Module
' The example displays the following output:
'       Population Change, New York, 1950-2000
'       
'       Year      Population Annual Rate
'       1950       7,891,957          NA
'       1960       7,781,984     -0.14 %
'       1970       7,894,862      0.15 %
'       1980       7,071,639     -1.04 %
'       1990       7,322,564      0.35 %
'       2000       8,008,278      0.94 %
'       1950-2000                 0.03 %

Pour renvoyer plusieurs valeurs à partir d’une méthode sans utiliser de out paramètres (en C#) ou ByRef de paramètres (dans 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 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,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>(T1, T2, T3, T4, T5, T6, T7)

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

Propriétés

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

Méthodes

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

Implémentations d’interfaces explicites

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

Méthodes d’extension

Deconstruct<T1,T2,T3,T4,T5,T6,T7>(Tuple<T1,T2,T3,T4,T5,T6,T7>, T1, T2, T3, T4, T5, T6, T7)	Décompose un tuple avec 7 éléments dans des variables distinctes.
ToValueTuple<T1,T2,T3,T4,T5,T6,T7>(Tuple<T1,T2,T3,T4,T5,T6,T7>)	Convertit une instance de la classe `Tuple` en une instance de la structure `ValueTuple`.

S’applique à

Partager via