Tuple Clase

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

Tuple.cs

Proporciona los métodos estáticos para crear objetos de tupla.

public ref class Tuple abstract sealed

public static class Tuple

type Tuple = class

Public Class Tuple

Herencia

Object

Tuple

Ejemplos

En el ejemplo siguiente se crea una tupla de 8 (octupla) que contiene números primos menores que 20.

var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1);
// The example displays the following output:
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

open System

let primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
printfn $"Prime numbers less than 20: {primes.Item1}, {primes.Item2}, {primes.Item3}, {primes.Item4}, {primes.Item5}, {primes.Item6}, {primes.Item7}, and {primes.Rest.Item1}"
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Dim primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1)
' The example displays the following output:
'     Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Comentarios

Una tupla es una estructura de datos que tiene un número específico y una secuencia de elementos. Un ejemplo de una tupla es una estructura de datos con tres elementos (conocidos como tres tuplas o triples) que se usan para almacenar un identificador como el nombre de una persona en el primer elemento, un año en el segundo elemento y los ingresos de la persona para ese año en el tercer elemento. .NET Framework admite directamente tuplas con uno a siete elementos. Además, puede crear tuplas de ocho o más elementos anidando objetos de tupla en la Rest propiedad de un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto .

Las tuplas se usan normalmente de cuatro maneras:

• 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.

• Para devolver varios valores de un método sin usar out parámetros (en C#) o ByRef parámetros (en Visual Basic).

• 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 tiempo de inicio. Si proporciona un Tuple<T1,T2,T3> objeto como argumento de método, puede proporcionar la rutina de inicio del subproceso con tres elementos de datos.

La Tuple clase no representa una tupla. En su lugar, es una clase que proporciona métodos estáticos para crear instancias de los tipos de tupla admitidos por .NET Framework. Proporciona métodos auxiliares que se pueden llamar a para crear instancias de objetos de tupla sin tener que especificar explícitamente el tipo de cada componente de tupla.

Aunque puede crear una instancia de una clase de tupla llamando a su constructor de clases, el código para hacerlo puede resultar complicado. En el ejemplo siguiente se usa un constructor de clase para crear una tupla de 7 o sepuple que contiene datos de población para la ciudad de Nueva York para cada censo de 1950 a 2000.

// Create a 7-tuple.
var population = new Tuple<string, int, int, int, int, int, int>(
                           "New York", 7891957, 7781984, 
                           7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple<string, int, int, int, int, int, int>(
                            "New York", 7891957, 7781984, 
                            7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer) _
                           ("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

Crear el mismo objeto de tupla mediante un método auxiliar es más sencillo, como se muestra en el ejemplo siguiente.

// Create a 7-tuple.
var population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

Los Create métodos auxiliares admiten directamente la creación de objetos de tupla que tienen de uno a ocho componentes (es decir, singletons a octuples). Aunque no hay ningún límite práctico para el número de componentes que puede tener una tupla, los métodos auxiliares no están disponibles para crear una tupla con nueve o más componentes. Para crear esta tupla, debe llamar al Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructor .

Nota:

Para obtener información adicional y ejemplos que usan tuplas, consulte la documentación de los tipos de tupla individuales en .NET Framework. Se muestran en la sección Ver también al final de este tema.

Métodos

Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)	Crea una nueva tupla de 8 u óctuple.
Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)	Crea una nueva tupla de 7 o séptuplo.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Crea una nueva tupla de 6 o séxtuplo.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)	Crea una nueva tupla de 5 o quíntuplo.
Create<T1,T2,T3,T4>(T1, T2, T3, T4)	Crea una nueva tupla de 4 o cuádruplo.
Create<T1,T2,T3>(T1, T2, T3)	Crea una nueva tupla de 3 o triple.
Create<T1,T2>(T1, T2)	Crea una nueva tupla de 2 o par.
Create<T1>(T1)	Crea una nueva tupla de 1 o singleton.

Consulte también

• Tuple<T1>
• Tuple<T1,T2>
• 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>