Tuple Classe

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Fornece métodos estáticos para criar objetos de tupla.

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.

Observação

Para obter informações e exemplos adicionais que usam tuplas, consulte a documentação dos tipos de tupla individuais no .NET Framework. Elas estão listadas na seção Veja Também no final deste tópico.

Métodos

Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)	Cria uma nova tupla de 8 ou octupla.
Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)	Cria uma nova tupla de 7 ou um sétuplo.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Cria uma nova tupla de 6 ou sêxtupla.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)	Cria uma nova tupla de 5 ou quíntuplo.
Create<T1,T2,T3,T4>(T1, T2, T3, T4)	Cria uma nova tupla de 4 ou quádrupla.
Create<T1,T2,T3>(T1, T2, T3)	Cria uma nova tupla de 3 ou um triplo.
Create<T1,T2>(T1, T2)	Cria uma nova tupla de 2 ou par.
Create<T1>(T1)	Cria uma nova tupla de 1 ou singleton.

Aplica-se a

Compartilhar via