Tuple Classe

Definição

public ref class Tuple abstract sealed

public static class Tuple

type Tuple = class

Public Class Tuple

Herança

Object

Tuple

Exemplos

O exemplo a seguir cria uma octupla (octupla) de 8 tuplas que contém 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

Comentários

Uma tupla é uma estrutura de dados que tem um número específico e uma sequência de elementos. Um exemplo de tupla é uma estrutura de dados com três elementos (conhecidos como 3 tuplas ou triplos) que são usados para armazenar um identificador, como o nome de uma pessoa no primeiro elemento, um ano no segundo elemento e a renda da pessoa para esse ano no terceiro elemento. O .NET Framework dá suporte direto a tuplas com um a sete elementos. Além disso, você pode criar tuplas de oito ou mais elementos aninhando objetos de tupla na Rest propriedade de um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto.

As tuplas são comumente usadas de quatro maneiras:

• Para representar um único conjunto de dados. Por exemplo, uma tupla pode representar um registro de banco de dados, e seus componentes podem representar campos individuais do registro.

• Para fornecer acesso fácil a, e a manipulação de um conjunto de dados.

• Para retornar vários valores de um método sem usar out parâmetros (em C#) ou ByRef parâmetros (em Visual Basic).

• Para passar vários valores para um método por meio de um parâmetro único. Por exemplo, o Thread.Start(Object) método tem um único parâmetro que permite fornecer um valor para o método que o thread executa no momento da inicialização. Se você fornecer um Tuple<T1,T2,T3> objeto como o argumento do método, poderá fornecer a rotina de inicialização do thread com três itens de dados.

A Tuple classe em si não representa uma tupla. Em vez disso, é uma classe que fornece métodos estáticos para criar instâncias dos tipos de tupla compatíveis com o .NET Framework. Ele fornece métodos auxiliares que você pode chamar para instanciar objetos de tupla sem precisar especificar explicitamente o tipo de cada componente de tupla.

Embora você possa criar uma instância de uma classe de tupla chamando seu construtor de classe, o código para fazer isso pode ser complicado. O exemplo a seguir usa um construtor de classe para criar uma tupla de 7 ou septupla que contém dados populacionais para Nova 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

Criar o mesmo objeto de tupla usando um método auxiliar é mais simples, como mostra o exemplo a seguir.

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

Os Create métodos auxiliares dão suporte diretamente à criação de objetos de tupla que têm de um a oito componentes (ou seja, singletons por octuplas). Embora não haja um limite prático para o número de componentes que uma tupla pode ter, os métodos auxiliares não estão disponíveis para criar uma tupla com nove ou mais componentes. Para criar essa tupla, você deve chamar o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor.

Métodos

Aplica-se a

Confira também

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