Tuple<T1,T2,T3,T4,T5> Tuple<T1,T2,T3,T4,T5> Tuple<T1,T2,T3,T4,T5> Tuple<T1,T2,T3,T4,T5> Class

Definición

generic <typename T1, typename T2, typename T3, typename T4, typename T5>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

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

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

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

Parámetros de tipo

Herencia

ObjectObjectObjectObject

Tuple<T1,T2,T3,T4,T5>Tuple<T1,T2,T3,T4,T5>Tuple<T1,T2,T3,T4,T5>Tuple<T1,T2,T3,T4,T5>

Atributos

SerializableAttribute

Implementaciones

IStructuralComparableIStructuralComparableIStructuralComparableIStructuralComparable IStructuralEquatableIStructuralEquatableIStructuralEquatableIStructuralEquatable IComparableIComparableIComparableIComparable

Comentarios

Una tupla es una estructura de datos que tiene un número específico y una secuencia de valores.A tuple is a data structure that has a specific number and sequence of values. La Tuple<T1,T2,T3,T4,T5> clase representa una tupla de 5 o quíntuplo, que es una tupla que tiene cinco componentes.The Tuple<T1,T2,T3,T4,T5> class represents a 5-tuple, or quintuple, which is a tuple that has five components.

Puede crear instancias de un Tuple<T1,T2,T3,T4,T5> objeto llamando al Tuple<T1,T2,T3,T4,T5> constructor o al método estático Tuple.Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5) .You can instantiate a Tuple<T1,T2,T3,T4,T5> object by calling either the Tuple<T1,T2,T3,T4,T5> constructor or the static Tuple.Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5) method. Puede recuperar el valor de los componentes de la tupla mediante las propiedades de instancia Item1 Item3, Item2,, Item4y Item5 de solo lectura.You can retrieve the value of the tuple's components by using the read-only Item1, Item2, Item3, Item4, and Item5 instance properties.

Las tuplas se utilizan normalmente de cuatro maneras diferentes:Tuples are commonly used in four different ways:

• Para representar un único conjunto de datos.To represent a single set of data. Por ejemplo, una tupla puede representar un registro de base de datos y sus componentes pueden representar campos individuales del registro.For example, a tuple can represent a database record, and its components can represent individual fields of the record.

• Para facilitar el acceso y la manipulación de un conjunto de datos.To provide easy access to, and manipulation of, a data set. En el ejemplo siguiente se define una Tuple<T1,T2,T3,T4,T5> matriz de objetos que contienen los nombres de las copias de seguridad en el fútbol americano, el número de juegos en los que se reproducen y el número de concursos, los metros totales obtenidos y la puntuación de touchdowns durante esos juegos.The following example defines an array of Tuple<T1,T2,T3,T4,T5> objects that contain the names of running backs in American football, the number of games in which they played, and the number of carries, total yards gained, and touchdowns scored during those games. La matriz se pasa al ComputeStatistics método, que calcula cada número de transcursos por juego, promedio de metros por juego, media de metros por transporte y promedio de touchdowns por intento.The array is passed to the ComputeStatistics method, which calculates each running back's number of carries per game, average yards per game, average yards per carry, and average number of touchdowns per attempt.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        // Organization of runningBacks 5-tuple:
        //    Component 1: Player name
        //    Component 2: Number of games played
        //    Component 3: Number of attempts (carries)
        //    Component 4: Number of yards gained 
        //    Component 5: Number of touchdowns   
        Tuple<string, int, int, int, int>[] runningBacks =
             { Tuple.Create("Payton, Walter", 190, 3838, 16726, 110),  
               Tuple.Create("Sanders, Barry", 153, 3062, 15269, 99),            
               Tuple.Create("Brown, Jim", 118, 2359, 12312, 106),            
               Tuple.Create("Dickerson, Eric", 144, 2996, 13259, 90),            
               Tuple.Create("Faulk, Marshall", 176, 2836, 12279, 100) }; 
        // Calculate statistics.
        // Organization of runningStats 5-tuple:
        //    Component 1: Player name
        //    Component 2: Number of attempts per game
        //    Component 3: Number of yards per game
        //    Component 4: Number of yards per attempt 
        //    Component 5: Number of touchdowns per attempt   
        Tuple<string, double, double, double, double>[] runningStats  = 
            ComputeStatistics(runningBacks);
  
        // Display the result.          
        Console.WriteLine("{0,-16} {1,5} {2,6} {3,7} {4,7} {5,7} {6,7} {7,5} {8,7}\n", 
                          "Name", "Games", "Att", "Att/Gm", "Yards", "Yds/Gm",
                          "Yds/Att", "TD", "TD/Att");
        for (int ctr = 0; ctr < runningBacks.Length; ctr++)
           Console.WriteLine("{0,-16} {1,5} {2,6:N0} {3,7:N1} {4,7:N0} {5,7:N1} {6,7:N2} {7,5} {8,7:N3}\n", 
                             runningBacks[ctr].Item1, runningBacks[ctr].Item2, runningBacks[ctr].Item3, 
                             runningStats[ctr].Item2, runningBacks[ctr].Item4, runningStats[ctr].Item3, 
                             runningStats[ctr].Item4, runningBacks[ctr].Item5, runningStats[ctr].Item5);
     }
  
     private static Tuple<string, double, double, double, double>[] ComputeStatistics(
                  Tuple<string, int, int, int, int>[] players) 
     {
        Tuple<string, double, double, double, double> result; 
        var list = new List<Tuple<string, double, double, double, double>>();
        
        foreach (var player in players)
        {
           // Create result object containing player name and statistics.
           result = Tuple.Create(player.Item1,  
                                 player.Item3/((double)player.Item2), 
                                 player.Item4/((double)player.Item2),
                                 player.Item4/((double)player.Item3), 
                                 player.Item5/((double)player.Item3));
           list.Add(result);         
        }
        return list.ToArray();  
     }
  }
  // The example displays the following output:
  //    Name             Games    Att  Att/Gm   Yards  Yds/Gm Yds/Att    TD  TD/Att
  //    
  //    Payton, Walter     190  3,838    20.2  16,726    88.0    4.36   110   0.029
  //    
  //    Sanders, Barry     153  3,062    20.0  15,269    99.8    4.99    99   0.032
  //    
  //    Brown, Jim         118  2,359    20.0  12,312   104.3    5.22   106   0.045
  //    
  //    Dickerson, Eric    144  2,996    20.8  13,259    92.1    4.43    90   0.030
  //    
  //    Faulk, Marshall    176  2,836    16.1  12,279    69.8    4.33   100   0.035
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        ' Organization of runningBacks 5-tuple:
        '    Component 1: Player name
        '    Component 2: Number of games played
        '    Component 3: Number of attempts (carries)
        '    Component 4: Number of yards gained 
        '    Component 5: Number of touchdowns   
        Dim runningBacks() =
            { Tuple.Create("Payton, Walter", 190, 3838, 16726, 110),  
              Tuple.Create("Sanders, Barry", 153, 3062, 15269, 99),            
              Tuple.Create("Brown, Jim", 118, 2359, 12312, 106),            
              Tuple.Create("Dickerson, Eric", 144, 2996, 13259, 90),            
              Tuple.Create("Faulk, Marshall", 176, 2836, 12279, 100) } 
        ' Calculate statistics.
        ' Organization of runningStats 5-tuple:
        '    Component 1: Player name
        '    Component 2: Number of attempts per game
        '    Component 3: Number of yards per game
        '    Component 4: Number of yards per attempt 
        '    Component 5: Number of touchdowns per attempt   
        Dim runningStats() = ComputeStatistics(runningBacks)
  
        ' Display the result.          
        Console.WriteLine("{0,-16} {1,5} {2,6} {3,7} {4,7} {5,7} {6,7} {7,5} {8,7}", 
                          "Name", "Games", "Att", "Att/Gm", "Yards", "Yds/Gm",
                          "Yds/Att", "TD", "TD/Att")
        Console.WriteLine()
        For ctr As Integer = 0 To runningBacks.Length - 1
           Console.WriteLine("{0,-16} {1,5} {2,6:N0} {3,7:N1} {4,7:N0} {5,7:N1} {6,7:N2} {7,5} {8,7:N3}", 
                             runningBacks(ctr).Item1, runningBacks(ctr).Item2, runningBacks(ctr).Item3, 
                             runningStats(ctr).Item2, runningBacks(ctr).Item4, runningStats(ctr).Item3, 
                             runningStats(ctr).Item4, runningBacks(ctr).Item5, runningStats(ctr).Item5)
           Console.WriteLine()  
        Next     
     End Sub
  
     Private Function ComputeStatistics(players() As Tuple(Of String, Integer, Integer, Integer, Integer)) _
                      As Tuple(Of String, Double, Double, Double, Double)()
  
        Dim result As Tuple(Of String, Double, Double, Double, Double)
        Dim list As New List(Of Tuple(Of String, Double, Double, Double, Double))()
        
        For Each player In players
           ' Create result object containing player name and statistics.
           result = Tuple.Create(player.Item1,  
                              player.Item3/player.Item2, player.Item4/player.Item2,
                              player.Item4/player.Item3, player.Item5/player.Item3)
           list.Add(result)         
        Next
        Return list.ToArray()  
     End Function
  End Module
  ' The example displays the following output:
  '    Name             Games    Att  Att/Gm   Yards  Yds/Gm Yds/Att    TD  TD/Att
  '    
  '    Payton, Walter     190  3,838    20.2  16,726    88.0    4.36   110   0.029
  '    
  '    Sanders, Barry     153  3,062    20.0  15,269    99.8    4.99    99   0.032
  '    
  '    Brown, Jim         118  2,359    20.0  12,312   104.3    5.22   106   0.045
  '    
  '    Dickerson, Eric    144  2,996    20.8  13,259    92.1    4.43    90   0.030
  '    
  '    Faulk, Marshall    176  2,836    16.1  12,279    69.8    4.33   100   0.035
  

• Para devolver varios valores de un método sin el uso de out parámetros (en C#) o ByRef parámetros (en Visual Basic).To return multiple values from a method without the use of out parameters (in C#) or ByRef parameters (in Visual Basic). Por ejemplo, en el ejemplo anterior se devuelven sus estadísticas calculadas, junto con el nombre del reproductor, en Tuple<T1,T2,T3,T4,T5> una matriz de objetos.For example, the previous example returns its computed statistics, along with the name of the player, in an array of Tuple<T1,T2,T3,T4,T5> objects.

• Para pasar varios valores a un método a través de un solo parámetro.To pass multiple values to a method through a single parameter. Por ejemplo, el Thread.Start(Object) método tiene un único parámetro que le permite proporcionar un valor al método que el subproceso ejecuta en el inicio.For example, the Thread.Start(Object) method has a single parameter that lets you supply one value to the method that the thread executes at startup. Si proporciona un Tuple<T1,T2,T3,T4,T5> objeto como argumento del método, puede proporcionar la rutina de inicio del subproceso con cinco elementos de datos.If you supply a Tuple<T1,T2,T3,T4,T5> object as the method argument, you can supply the thread's startup routine with five items of data.

Constructores

Propiedades

Métodos

Implementaciones de interfaz explícitas

Métodos de extensión

Se aplica a

Consulte también:

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