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

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Representa uma n-tupla, onde 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

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.Serializable]
public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

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

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface 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

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

Parâmetros de Tipo Genérico

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>

Atributos: SerializableAttribute

Implementações: IStructuralComparable IStructuralEquatable IComparable ITuple

Observações

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

Pode instanciar 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 seguinte cria uma 8-tupla (octuplo) que contém números primos menores que 20. Note que utiliza inferência de tipos 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

Também pode instanciar um objeto n-tuplo com oito ou mais componentes chamando o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor. O exemplo seguinte usa o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor para criar uma 8-tupla 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))

Note

Para criar um n-tuplo com nove ou mais componentes, deve chamar o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor. Os métodos de fábrica estática da Tuple classe não suportam a criação de Tuple objetos com mais de oito componentes.

Para instanciar um n-tuplo que tem oito ou mais componentes com o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor, fornece um objeto genérico Tuple como rest parâmetro para definir a oitava à ncomponente da tupla. Ao aninhar objetos genéricos Tuple desta forma, pode-se criar uma tupla que não tem limitação prática no número dos seus componentes.

O exemplo seguinte cria uma tupla de 17 que contém dados populacionais da 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écada. A 17-tupla é criada ao aninhar 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 valor do rest parâmetro no Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor de classes.) Este Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto está, por sua vez, aninhado num objeto exterior 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 classes do objeto exterior 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)

Pode recuperar o valor dos primeiros sete componentes da tupla usando as propriedades de leitura somente Item1, Item2, Item3, Item4, Item5, Item6, , e Item7 instância. Quaisquer componentes adicionais estão aninhados e podem ser recuperados da Rest propriedade. No exemplo anterior, as Item1 propriedades passantes Item7 recuperam a primeira até à sétima componente da tupla. Os componentes oitavo a décimo quarto estão contidos na tupla que está aninhada no segundo nível, e são representados pelas Rest.Item1 propriedades passantes Rest.Item7 . Os componentes décimo quinto a décimo sétimo estão contidos na tupla que está aninhada no terceiro nível, e são representados pelas propriedades de Rest.Rest.Item1 pensamento Rest.Rest.Item3 .

As tuplas são frequentemente usadas de quatro formas diferentes:

Para representar um único conjunto de dados. Por exemplo, uma tupla pode representar um registo de base de dados, e os seus componentes podem representar campos individuais do registo.
Proporcionar fácil acesso e manipulação de um conjunto de dados.
Devolver múltiplos valores de um método sem o uso de parâmetros out (em C#) ou parâmetros ByRef (em Visual Basic). Por exemplo, o exemplo anterior devolve as suas estatísticas calculadas, juntamente com o nome da cidade, num Tuple<T1,T2,T3,T4,T5,T6,T7> objeto.
Passar múltiplos valores a um método através de um único parâmetro. Por exemplo, o Thread.Start(Object) método tem um único parâmetro que permite fornecer um valor ao método que a thread executa no arranque. Se fornecer um Tuple<T1,T2,T3,T4,T5,T6,T7> objeto como argumento de método, pode fornecer a rotina de arranque do thread com sete itens de dados.

Construtores

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

Propriedades

Name	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

Name	Description
Equals(Object)	Devolve 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 de 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 atual Object. (Herdado de Object)
ToString()	Devolve uma cadeia que representa o valor desta Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> instância.

Implementações de Interface Explícita

Name	Description
IComparable.CompareTo(Object)	Compara o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> com um objeto especificado e devolve um inteiro que indica se o objeto atual está antes, depois ou na mesma posição que o objeto especificado na ordem de ordenaçã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 devolve um inteiro que indica se o objeto atual está antes, depois ou na mesma posição que o objeto especificado na ordem de ordenação.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Devolve um valor que indica se o objeto atual Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> é igual a um objeto especificado com base num método de comparação especificado.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Calcula o código de hash para o 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 em .`Tuple`

Aplica-se a

Ver também

Comentários

Esta página foi útil?