Tuple<T1,T2> Clase

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Representa una tupla de 2 o par.

C#

public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

C#

public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

C#

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

Parámetros de tipo

T1

Tipo del primer componente de la tupla.

T2

Tipo del segundo componente de la tupla.

Herencia

Object

Tuple<T1,T2>

Atributos

SerializableAttribute

Implementaciones

IStructuralComparable IStructuralEquatable IComparable ITuple

Comentarios

Una tupla es una estructura de datos que tiene un número específico y una secuencia de valores. La Tuple<T1,T2> clase representa una tupla de 2 o un par, que es una tupla que tiene dos componentes. Una tupla de 2 es similar a una KeyValuePair<TKey,TValue> estructura.

Puede crear una instancia de un Tuple<T1,T2> objeto llamando al Tuple<T1,T2> constructor o al método estático Tuple.Create<T1,T2>(T1, T2) . Puede recuperar los valores de los componentes de la tupla mediante las propiedades de solo lectura Item1 y Item2 de instancia.

Las tuplas se usan normalmente de cuatro maneras diferentes:

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

• Para proporcionar un acceso sencillo y la manipulación de un conjunto de datos. En el ejemplo siguiente se define una matriz de Tuple<T1,T2> objetos que contienen los nombres de los alumnos y sus puntuaciones de prueba correspondientes. A continuación, itera la matriz para calcular la puntuación media de la prueba.

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Tuple<string, Nullable<int>>[] scores = 
                      { new Tuple<string, Nullable<int>>("Jack", 78),
                        new Tuple<string, Nullable<int>>("Abbey", 92), 
                        new Tuple<string, Nullable<int>>("Dave", 88),
                        new Tuple<string, Nullable<int>>("Sam", 91), 
                        new Tuple<string, Nullable<int>>("Ed", null),
                        new Tuple<string, Nullable<int>>("Penelope", 82),
                        new Tuple<string, Nullable<int>>("Linda", 99),
                        new Tuple<string, Nullable<int>>("Judith", 84) };
        int number;
        double mean = ComputeMean(scores, out number);
        Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number);
     }
  
     private static double ComputeMean(Tuple<string, Nullable<int>>[] scores, out int n) 
     {
        n = 0;      
        int sum = 0;
        foreach (var score in scores)
        {
           if (score.Item2.HasValue)
           { 
              n += 1;
              sum += score.Item2.Value;
           }
        }     
        if (n > 0)
           return sum / (double) n;
        else
           return 0;
     }
  }
  // The example displays the following output:
  //       Average test score: 87.71 (n=7)
  

• 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, en el ejemplo siguiente se usa un Tuple<T1,T2> objeto para devolver el cociente y el resto resultante de la división de enteros.

  C#

  using System;
  
  public class Class1
  {
     public static void Main()
     {
        int dividend, divisor;
        Tuple<int, int> result;
        
        dividend = 136945; divisor = 178;
        result = IntegerDivide(dividend, divisor);
        if (result != null)
           Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                             dividend, divisor, result.Item1, result.Item2);
        else
           Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
                          
        dividend = Int32.MaxValue; divisor = -2073;
        result = IntegerDivide(dividend, divisor);
        if (result != null)
           Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                             dividend, divisor, result.Item1, result.Item2);
        else
           Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
     }
  
     private static Tuple<int, int> IntegerDivide(int dividend, int divisor)
     {
        try {
           int remainder;
           int quotient = Math.DivRem(dividend, divisor, out remainder);
           return new Tuple<int, int>(quotient, remainder);
        }   
        catch (DivideByZeroException) {
           return null;
        }      
     }
  }
  // The example displays the following output:
  //       136945 \ 178 = 769, remainder 63
  //       2147483647 \ -2073 = -1035930, remainder 757
  

• 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> objeto como argumento de método, puede proporcionar la rutina de inicio del subproceso con dos elementos de datos.

Constructores

Tuple<T1,T2>(T1, T2)

Inicializa una nueva instancia de la clase Tuple<T1,T2>.

Propiedades

Item1	Obtiene el valor del primer componente del objeto Tuple<T1,T2> actual.
Item2	Obtiene el valor del segundo componente del objeto Tuple<T1,T2> actual.

Métodos

Equals(Object)	Devuelve un valor que indica si el objeto Tuple<T1,T2> actual es igual que el objeto especificado.
GetHashCode()	Devuelve el código hash del objeto Tuple<T1,T2> 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>.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)	Compara el objeto Tuple<T1,T2> 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> 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 si 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> 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> 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>(Tuple<T1,T2>, T1, T2)	Deconstruye una tupla con dos elementos en variables independientes.
ToValueTuple<T1,T2>(Tuple<T1,T2>)	Convierte una instancia de la clase Tuple en una instancia de la estructura ValueTuple.

Se aplica a

Consulte también

• Tuple
• Tuple<T1>
• 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>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>