Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Classe

Definição

Namespace:

System

Assemblies:

netstandard.dll, System.Runtime.dll

Origem:

Tuple.cs

Representa uma n tupla, em que n é 8 ou maior.

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TRest>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple

public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7, TRest)
Implements IComparable, IStructuralComparable, IStructuralEquatable, ITuple

Parâmetros de tipo

T1

O tipo do primeiro componente da tupla.

T2

O tipo do segundo componente da tupla.

T3

O tipo do terceiro componente da tupla.

T4

O tipo do quarto componente da tupla.

T5

O tipo do quinto componente da tupla.

T6

O tipo do sexto componente da tupla.

T7

O tipo do sétimo componente da tupla.

TRest

Qualquer objeto genérico Tuple que defina os tipos dos componentes restantes da tupla.

Herança

Object

Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

Implementações

IStructuralComparable IStructuralEquatable IComparable ITuple

Comentários

Uma tupla é uma estrutura de dados que tem um número específico e uma sequência de valores. A Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe representa uma n tupla que tem oito ou mais componentes.

Você pode criar uma instância de um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto com exatamente oito componentes chamando o método estático Tuple.Create . O exemplo a seguir cria uma octupla (octupla) de 8 tuplas que contém números primos menores que 20. Observe que ele usa inferência de tipo para determinar o tipo de cada componente.

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

Você também pode criar uma instância de um objeto n tupla com oito ou mais componentes chamando o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor. O exemplo a seguir usa o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor para criar uma tupla de 8 que é equivalente à tupla criada no exemplo anterior.

var primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
             Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19));

let primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
               Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19))

Dim primes = New Tuple(Of Int32, Int32, Int32, Int32, Int32, Int32, Int32, _ 
             Tuple(Of Int32))(2, 3, 5, 7, 11, 13, 17, New Tuple(Of Int32)(19))

Observação

Para criar uma n tupla com nove ou mais componentes, você deve chamar o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor. Os métodos de fábrica estáticos da Tuple classe não dão suporte à criação de objetos com mais de Tuple oito componentes.

Para instanciar uma n tupla que tem oito ou mais componentes com o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor, você fornece um objeto genérico Tuple como o rest parâmetro para definir os componentes de oitava a nda tupla. Aninhando objetos genéricos Tuple dessa forma, você pode criar uma tupla que não tem nenhuma limitação prática sobre o número de componentes.

O exemplo a seguir cria uma tupla de 17 tuplas que contém dados populacionais para a cidade de Detroit, Michigan, para cada censo nacional de 1860 a 2000. O primeiro componente da tupla é o nome da cidade. O segundo componente é a data de início da série de dados e o terceiro componente é a população na data de início. Cada componente subsequente fornece a população em intervalos de décadas. A tupla de 17 é criada aninhando um Tuple<T1,T2,T3> objeto dentro de um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto. (Ou seja, o Tuple<T1,T2,T3> objeto é fornecido como o valor do rest parâmetro no construtor de Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe.) Esse Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto, por sua vez, está aninhado em um objeto externo Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . (Ou seja, o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto é fornecido como o valor do rest parâmetro no construtor de classe do objeto externo Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .)

var from1980 = Tuple.Create(1203339, 1027974, 951270);
var from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>> 
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980);
var population = new Tuple<string, int, int, int, int, int, int,
    Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>> 
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910);

let from1980 = Tuple.Create(1203339, 1027974, 951270)
let from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>(465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
let population = new Tuple<string, int, int, int, int, int, int, Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>>("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Dim from1980 = Tuple.Create(1203339, 1027974, 951270)
Dim from1910 As New Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, _
    Tuple(Of Integer, Integer, Integer)) _
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer, _ 
    Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, Tuple(Of Integer, Integer, Integer))) _
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Você pode recuperar o valor dos sete primeiros componentes da tupla usando as propriedades somente Item1leitura, Item2, Item3, , Item4e Item5Item6Item7 instância. Todos os componentes adicionais são aninhados e podem ser recuperados da Rest propriedade. No exemplo anterior, as Item1 propriedades por meio Item7 recuperam os primeiros e sétimos componentes da tupla. O oitavo a décimo quarto componentes estão contidos na tupla aninhada no segundo nível e são representados pelas Rest.Item1 propriedades por meio Rest.Item7 . Os 15º a 17º componentes estão contidos na tupla aninhada no terceiro nível e são representados pelas Rest.Rest.Item1 propriedades embora Rest.Rest.Item3 .

As tuplas são comumente usadas de quatro maneiras diferentes:

• 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 e manipulação de um conjunto de dados.

• Para retornar vários valores de um método sem o uso de out parâmetros (em C#) ou ByRef parâmetros (no Visual Basic). Por exemplo, o exemplo anterior retorna suas estatísticas computadas, juntamente com o nome da cidade, em um Tuple<T1,T2,T3,T4,T5,T6,T7> objeto.

• Para passar vários valores para um método por meio de um único parâmetro. 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 na inicialização. Se você fornecer um Tuple<T1,T2,T3,T4,T5,T6,T7> objeto como o argumento do método, poderá fornecer a rotina de inicialização do thread sete itens de dados.

Construtores

Nome	Description
Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>(T1, T2, T3, T4, T5, T6, T7, TRest)	Inicializa uma nova instância da classe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Propriedades

Nome	Description
Item1	Obtém o valor do primeiro componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item2	Obtém o valor do segundo componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item3	Obtém o valor do terceiro componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item4	Obtém o valor do quarto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item5	Obtém o valor do quinto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item6	Obtém o valor do sexto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Item7	Obtém o valor do sétimo componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Rest	Obtém os componentes restantes do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .

Métodos

Nome	Description
Equals(Object)	Retorna um valor que indica se o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> é igual a um objeto especificado.
GetHashCode()	Calcula o código hash do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o valor dessa Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> instância.

Implantações explícitas de interface

Nome	Description
IComparable.CompareTo(Object)	Compara o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> com um objeto especificado e retorna um inteiro que indica se o objeto atual está antes, depois ou na mesma posição que o objeto especificado na ordem de classificação.
IStructuralComparable.CompareTo(Object, IComparer)	Compara o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> com um objeto especificado usando um comparador especificado e retorna um inteiro que indica se o objeto atual está antes, depois ou na mesma posição que o objeto especificado na ordem de classificação.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Retorna um valor que indica se o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> é igual a um objeto especificado com base em um método de comparação especificado.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Calcula o código hash do objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> usando um método de computação especificado.
ITuple.Item[Int32]	Obtém o valor do elemento especificado Tuple .
ITuple.Length	Obtém o número de elementos no Tuple.

Confira também

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