Tuple<T1,T2,T3,T4> Classe

Définition

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

[System.Serializable]
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

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

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

type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    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

Héritage

Object

Tuple<T1,T2,T3,T4>

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> 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 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 tableau d’objets Tuple<T1,T2,T3,T4> qui contiennent les noms des lanceurs de baseball, le nombre d’innings qu’ils ont pitchés et le nombre d’exécutions gagnées (exécutions qui ont marqué sans erreurs de champ) et les coups 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 d’exécutions attribuées 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 hypothétique d’efficacité.

  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 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 du lanceur, dans un tableau d’objets Tuple<T1,T2,T3,T4> .

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

Voir aussi

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