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

Définition

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

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 et une séquence spécifiques de valeurs. La Tuple<T1,T2,T3,T4,T5,T6,T7> classe représente un tuple de 7 tuples ou septuple, qui est un tuple qui a sept composants.

Vous pouvez instancier un Tuple<T1,T2,T3,T4,T5,T6,T7> objet en appelant la méthode statique ou 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, Item2Item3, Item4, Item5et Item6Item7 des propriétés d’instance.

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 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 modification 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 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 paramètre unique 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 en tant qu’argument de méthode, vous pouvez fournir la routine de démarrage du thread avec sept éléments de données.

Voir aussi

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