Partager via


Tuple<T1,T2,T3,T4> Classe

Définition

Représente un objet de 4 tuples, ou quadruple.

generic <typename T1, typename T2, typename T3, typename T4>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
generic <typename T1, typename T2, typename T3, typename T4>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple
public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple
[System.Serializable]
public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple
[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple
Public Class Tuple(Of T1, T2, T3, T4)
Implements IComparable, IStructuralComparable, IStructuralEquatable
Public Class Tuple(Of T1, T2, T3, T4)
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.

Héritage
Tuple<T1,T2,T3,T4>
Attributs
Implémente

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> classe représente un tuple de 4 tuples, ou quadruplé, qui est un tuple qui a quatre composants.

Vous pouvez instancier un Tuple<T1,T2,T3,T4> objet en appelant le Tuple<T1,T2,T3,T4> constructeur ou la méthode statique Tuple.Create<T1,T2,T3,T4>(T1, T2, T3, T4) . Vous pouvez récupérer la valeur des composants du tuple à l’aide des propriétés en lecture seuleItem1, et Item2Item3Item4 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 tableau d’objets qui contiennent les noms des lanceurs de Tuple<T1,T2,T3,T4> baseball, le nombre de manches qu’ils ont pitchées et le nombre d’exécutions gagnées (exécutions qui ont marqué sans erreurs de champ) et les frappes qu’ils ont abandonnés. Le tableau est passé à la ComputeStatistics méthode, qui calcule la moyenne de l’exécution acquise de chaque lanceur (le nombre moyen de exécutions abandonnés dans un jeu de neuf inning) et le nombre moyen de coups abandonnés par inning. La méthode utilise également ces deux moyennes pour calculer une moyenne d’efficacité hypothétique.

    using System;
    using System.Collections.Generic;
    
    public class Example
    {
       public static void Main()
       {
          Tuple<string, decimal, int, int>[] pitchers  =  
               { Tuple.Create("McHale, Joe", 240.1m, 221, 96),
                 Tuple.Create("Paul, Dave", 233.1m, 231, 84), 
                 Tuple.Create("Williams, Mike", 193.2m, 183, 86),
                 Tuple.Create("Blair, Jack", 168.1m, 146, 65), 
                 Tuple.Create("Henry, Walt", 140.1m, 96, 30),
                 Tuple.Create("Lee, Adam", 137.2m, 109, 45),
                 Tuple.Create("Rohr, Don", 101.0m, 110, 42) };
          Tuple<string, double, double, double>[] results= ComputeStatistics(pitchers);
    
          // Display the results.
          Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}\n", 
                            "Pitcher", "ERA", "Hits/Inn.", "Effectiveness");
          foreach (var result in results)
             Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                            result.Item1, result.Item2, result.Item3, result.Item4);
       }
    
       private static Tuple<string, double, double, double>[] ComputeStatistics(Tuple<string, decimal, int, int>[] pitchers)
       {    
          var list = new List<Tuple<string, double, double, double>>();
          Tuple<string, double, double, double> result;
    
          foreach (var pitcher in pitchers)
          {
             // Decimal portion of innings pitched represents 1/3 of an inning
             double innings = (double) Math.Truncate(pitcher.Item2);
             innings = innings + (((double)pitcher.Item2 - innings) * .33);
             
             double ERA = pitcher.Item4/innings * 9;
             double hitsPerInning = pitcher.Item3/innings;
             double EI = (ERA * 2 + hitsPerInning * 9)/3;
             result = new Tuple<string, double, double, double>
                               (pitcher.Item1, ERA, hitsPerInning, EI);
             list.Add(result);
          }
          return list.ToArray();
       }
    }
    // The example displays the following output;
    //       Pitcher                    ERA   Hits/Inn.   Effectiveness
    //       
    //       McHale, Joe               3.60        0.92            5.16
    //       Paul, Dave                3.24        0.99            5.14
    //       Williams, Mike            4.01        0.95            5.52
    //       Blair, Jack               3.48        0.87            4.93
    //       Henry, Walt               1.93        0.69            3.34
    //       Lee, Adam                 2.95        0.80            4.36
    //       Rohr, Don                 3.74        1.09            5.76
    
    open System
    
    let computeStatistics (pitchers: Tuple<string, decimal, int, int>[]) =
        [| for pitcher in pitchers do
            // Decimal portion of innings pitched represents 1/3 of an inning
            let innings =  truncate (double pitcher.Item2) |> double
            let innings = innings + (double pitcher.Item2 - innings) * 0.33
            
            let ERA = double pitcher.Item4 / innings * 9.
            let hitsPerInning = double pitcher.Item3 / innings
            let EI = (ERA * 2. + hitsPerInning * 9.) / 3.
            Tuple<string, double, double, double>(pitcher.Item1, ERA, hitsPerInning, EI)|]
    
    let pitchers  =  
        [| Tuple.Create("McHale, Joe", 240.1m, 221, 96)
           Tuple.Create("Paul, Dave", 233.1m, 231, 84)
           Tuple.Create("Williams, Mike", 193.2m, 183, 86)
           Tuple.Create("Blair, Jack", 168.1m, 146, 65) 
           Tuple.Create("Henry, Walt", 140.1m, 96, 30)
           Tuple.Create("Lee, Adam", 137.2m, 109, 45)
           Tuple.Create("Rohr, Don", 101.0m, 110, 42) |]
    
    let results = computeStatistics pitchers
    
    // Display the results.
    printfn "%-20s %9s %11s %15s\n" "Pitcher" "ERA" "Hits/Inn." "Effectiveness"
    for result in results do
        printfn $"{result.Item1,-20} {result.Item2,9:F2} {result.Item3,11:F2} {result.Item4,15:F2}"
    
    // The example displays the following output
    //       Pitcher                    ERA   Hits/Inn.   Effectiveness
    //       
    //       McHale, Joe               3.60        0.92            5.16
    //       Paul, Dave                3.24        0.99            5.14
    //       Williams, Mike            4.01        0.95            5.52
    //       Blair, Jack               3.48        0.87            4.93
    //       Henry, Walt               1.93        0.69            3.34
    //       Lee, Adam                 2.95        0.80            4.36
    //       Rohr, Don                 3.74        1.09            5.76
    
    Imports System.Collections.Generic
    
    Module Example
       Public Sub Main()
          Dim pitchers() =  
                   { Tuple.Create("McHale, Joe", 240.1d, 221, 96),
                     Tuple.Create("Paul, Dave", 233.1d, 231, 84), 
                     Tuple.Create("Williams, Mike", 193.2d, 183, 86),
                     Tuple.Create("Blair, Jack", 168.1d, 146, 65), 
                     Tuple.Create("Henry, Walt", 140.1d, 96, 30),
                     Tuple.Create("Lee, Adam", 137.2d, 109, 45),
                     Tuple.Create("Rohr, Don", 101.0d, 110, 42) }
          Dim results() = ComputeStatistics(pitchers)
    
          ' Display the results.
          Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}", "Pitcher", "ERA", "Hits/Inn.", "Effectiveness")
          Console.WriteLine()
          For Each result In results
             Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                            result.Item1, result.Item2, result.Item3, result.Item4)
          Next
       End Sub
       
       Private Function ComputeStatistics(pitchers() As Tuple(Of String, Decimal, Integer, Integer)) _ 
                                    As Tuple(Of String, Double, Double, Double)()
          Dim list As New List(Of Tuple(Of String, Double, Double, Double))
          Dim result As Tuple(Of String, Double, Double, Double)
    
          For Each pitcher As Tuple(Of String, Decimal, Integer, Integer) In pitchers
             ' Decimal portion of innings pitched represents 1/3 of an inning
             Dim innings As Double = CDbl(Math.Truncate(pitcher.Item2))
             innings = innings + ((pitcher.Item2 - innings) * .33)
             
             Dim ERA As Double = pitcher.Item4/innings * 9
             Dim hitsPerInning As Double = pitcher.Item3/innings
             Dim EI As Double = (ERA * 2 + hitsPerInning * 9)/3
             result = New Tuple(Of String, Double, Double, Double) _
                               (pitcher.Item1, ERA, hitsPerInning, EI)
             list.Add(result) 
          Next
          Return list.ToArray()
       End Function
    End Module
    ' The example displays the following output:
    '       Pitcher                    ERA   Hits/Inn.   Effectiveness
    '       
    '       McHale, Joe               3.60        0.92            5.16
    '       Paul, Dave                3.24        0.99            5.14
    '       Williams, Mike            4.01        0.95            5.52
    '       Blair, Jack               3.48        0.87            4.93
    '       Henry, Walt               1.93        0.69            3.34
    '       Lee, Adam                 2.95        0.80            4.36
    '       Rohr, Don                 3.74        1.09            5.76
    
  • 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 du pitcher, dans un tableau d’objets Tuple<T1,T2,T3,T4> .

  • 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> objet comme argument de méthode, vous pouvez fournir la routine de démarrage du thread avec quatre éléments de données.

Constructeurs

Tuple<T1,T2,T3,T4>(T1, T2, T3, T4)

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

Propriétés

Item1

Obtient la valeur du premier composant de l'objet Tuple<T1,T2,T3,T4> actif.

Item2

Obtient la valeur du deuxième composant de l'objet Tuple<T1,T2,T3,T4> actif.

Item3

Obtient la valeur du troisième composant de l'objet Tuple<T1,T2,T3,T4> actif.

Item4

Obtient la valeur du quatrième composant de l'objet Tuple<T1,T2,T3,T4> actif.

Méthodes

Equals(Object)

Retourne une valeur qui indique si l'objet Tuple<T1,T2,T3,T4> actuel est égal à un objet spécifié.

GetHashCode()

Retourne le code de hachage pour l'objet Tuple<T1,T2,T3,T4> 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>.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

Compare l’objet Tuple<T1,T2,T3,T4> 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> 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> 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> 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>(Tuple<T1,T2,T3,T4>, T1, T2, T3, T4)

Décompose un tuple avec 4 éléments dans des variables distinctes.

ToValueTuple<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>)

Convertit une instance de la classe Tuple en une instance de la structure ValueTuple.

S’applique à

Voir aussi