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

Definición

Representa una tupla de 6 o séxtuplo.

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

Parámetros de tipo

T1

Tipo del primer componente de la tupla.

T2

Tipo del segundo componente de la tupla.

T3

Tipo del tercer componente de la tupla.

T4

Tipo del cuarto componente de la tupla.

T5

Tipo del quinto componente de la tupla.

T6

Tipo del sexto componente de la tupla.

Herencia
Tuple<T1,T2,T3,T4,T5,T6>
Atributos
Implementaciones

Comentarios

Una tupla es una estructura de datos que tiene un número específico y una secuencia de valores. La Tuple<T1,T2,T3,T4,T5,T6> clase representa una tupla de 6, o sextuple, que es una tupla que tiene seis componentes.

Puede crear una instancia de un Tuple<T1,T2,T3,T4,T5,T6> objeto llamando al Tuple<T1,T2,T3,T4,T5,T6> método estático o Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) . Puede recuperar el valor de los componentes de la tupla mediante las propiedades de instancia de solo Item1lectura , Item4Item2Item3, Item5y Item6 .

Las tuplas se usan normalmente de cuatro maneras diferentes:

  • Para representar un único conjunto de datos. Por ejemplo, una tupla puede representar un registro de base de datos y sus componentes pueden representar campos individuales del registro.

  • Para proporcionar un acceso sencillo y la manipulación de un conjunto de datos. En el ejemplo siguiente se define un Tuple<T1,T2,T3,T4,T5,T6> objeto que contiene datos de población para la ciudad de Nueva York para cada censo de 1960 a 2000. La sextuple se pasa al ComputePopulationChange método , que calcula la tasa anual de cambio entre censos, así como la tasa anual de cambio para todo el período de 50 años.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          // Get population data for New York City, 1960-2000.
          var population = 
               Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278);
          var rate = ComputePopulationChange(population);
          // Display results.
          Console.WriteLine("Population Change, {0}, 1960-2000\n", population.Item1);
          Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
          Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA");
          Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
          Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
          Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
          Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
          Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50);
       }
    
       private static Tuple<string, double, double, double, double, double> ComputePopulationChange(
               Tuple<string, 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.Item6 - data.Item2)/data.Item2 );
          return rate;
       }           
    }
    // The example displays the following output:
    //       Population Change, New York, 1960-2000
    //       
    //       Year      Population Annual Rate
    //       1960       7,781,984          NA
    //       1970       7,894,862      0.15 %
    //       1980       7,071,639     -1.04 %
    //       1990       7,322,564      0.35 %
    //       2000       8,008,278      0.94 %
    //       1960-2000                 0.06 %
    
    open System
    
    let computePopulationChange (data: Tuple<string, int, int, int, int, int>) =  
        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.Item6 - data.Item2) / data.Item2))
    
    // Get population data for New York City, 1960-2000.
    let population = 
          Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278)
    let rate = computePopulationChange population
    // Display results.
    printfn $"Population Change, {population.Item1}, 1960-2000\n"
    printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
    printfn $"""1960      {population.Item2,10:N0} {"NA",11}"""
    printfn $"1970      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
    printfn $"1980      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}"
    printfn $"1990      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}"
    printfn $"2000      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}"
    printfn $"""1960-2000 {"",10:N0} {rate.Item6 / 50.,11:P2}"""
    
    // The example displays the following output:
    //       Population Change, New York, 1960-2000
    //       
    //       Year      Population Annual Rate
    //       1960       7,781,984          NA
    //       1970       7,894,862      0.15 %
    //       1980       7,071,639     -1.04 %
    //       1990       7,322,564      0.35 %
    //       2000       8,008,278      0.94 %
    //       1960-2000                 0.06 %
    
    Module Example
       Public Sub Main()
          ' Get population data for New York City, 1960-2000.
          Dim population = Tuple.Create(
                         "New York", 7781984, 7894862, 7071639, 7322564, 8008278)
          Dim rate = ComputePopulationChange(population)      
          ' Display results.
          Console.WriteLine("Population Change, {0}, 1960-2000", population.Item1)
          Console.WriteLine()
          Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
          Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA")
          Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
          Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
          Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
          Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
          Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/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)) _ 
               As Tuple(Of String, 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.Item6 - data.Item2)/data.Item2 )
          Return rate
       End Function           
    End Module
    ' The example displays the following output:
    '       Population Change, New York, 1960-2000
    '       
    '       Year      Population Annual Rate
    '       1960       7,781,984          NA
    '       1970       7,894,862      0.15 %
    '       1980       7,071,639     -1.04 %
    '       1990       7,322,564      0.35 %
    '       2000       8,008,278      0.94 %
    '       1960-2000                 0.06 %
    
  • Para devolver varios valores de un método sin el uso de out parámetros (en C#) o ByRef parámetros (en Visual Basic). Por ejemplo, el ejemplo anterior devuelve sus estadísticas calculadas, junto con el nombre de la ciudad, en un Tuple<T1,T2,T3,T4,T5,T6> objeto .

  • Para pasar varios valores a un método a través de un único parámetro. Por ejemplo, el Thread.Start(Object) método tiene un único parámetro que permite proporcionar un valor al método que ejecuta el subproceso en el inicio. Si proporciona un Tuple<T1,T2,T3,T4,T5,T6> objeto como argumento de método, puede proporcionar la rutina de inicio del subproceso con seis elementos de datos.

Constructores

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

Inicializa una nueva instancia de la clase Tuple<T1,T2,T3,T4,T5,T6>.

Propiedades

Item1

Obtiene el valor del primer componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Item2

Obtiene el valor del segundo componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Item3

Obtiene el valor del tercer componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Item4

Obtiene el valor del cuarto componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Item5

Obtiene el valor del quinto componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Item6

Obtiene el valor del sexto componente del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

Métodos

Equals(Object)

Devuelve un valor que indica si el objeto Tuple<T1,T2,T3,T4,T5,T6> actual es igual que el objeto especificado.

GetHashCode()

Devuelve el código hash del objeto Tuple<T1,T2,T3,T4,T5,T6> actual.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el valor de esta instancia de Tuple<T1,T2,T3,T4,T5,T6>.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)

Compara el objeto Tuple<T1,T2,T3,T4,T5,T6> actual con un objeto especificado y devuelve un entero que indica si el objeto actual es anterior, posterior o está en la misma posición que el objeto especificado en el criterio de ordenación.

IStructuralComparable.CompareTo(Object, IComparer)

Compara el objeto Tuple<T1,T2,T3,T4,T5,T6> actual con un objeto especificado utilizando un comparador especificado y devuelve un entero que indica si el objeto actual precede o sigue al objeto especificado, o bien se encuentra en la misma posición que dicho objeto en el criterio de ordenación.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Devuelve un valor que indica si el objeto Tuple<T1,T2,T3,T4,T5,T6> actual es igual que el objeto especificado según el método de comparación especificado.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Calcula el código hash del objeto Tuple<T1,T2,T3,T4,T5,T6> actual usando el método de cálculo especificado.

ITuple.Item[Int32]

Obtiene el valor del elemento Tuple especificado.

ITuple.Length

Obtiene el número de elementos de Tuple.

Métodos de extensión

Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)

Deconstruye una tupla con seis elementos en variables independientes.

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

Convierte una instancia de la clase Tuple en una instancia de la estructura ValueTuple.

Se aplica a

Consulte también