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

Definição

Espaço de Nomes:: System

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

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Origem:: Tuple.cs

Origem:: Tuple.cs

Origem:: Tuple.cs

Origem:: Tuple.cs

Origem:: Tuple.cs

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.

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

public:
 Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);

public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);

new Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'Rest -> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest>

Public Sub New (item1 As T1, item2 As T2, item3 As T3, item4 As T4, item5 As T5, item6 As T6, item7 As T7, rest As TRest)

Parâmetros

item1: T1

O valor do primeiro componente da tupla.

item2: T2

O valor do segundo componente da tupla.

item3: T3

O valor do terceiro componente da tupla.

item4: T4

O valor do quarto componente da tupla.

item5: T5

O valor do quinto componente da tupla.

item6: T6

O valor do sexto componente da tupla.

item7: T7

O valor do sétimo componente da tupla.

rest: TRest

Qualquer objeto genérico Tuple que contenha os valores dos componentes restantes da tupla.

Exceções

ArgumentException

rest não é um objeto genérico Tuple .

Exemplos

O exemplo seguinte cria um 17-tupla que contém dados populacionais da cidade de Detroit, Michigan, para cada censo 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. O exemplo utiliza duas camadas de nidificação para criar a 17-tupla: Define uma 7-tupla cujos componentes da terceira à sétima contêm dados populacionais de 1860 a 1900, uma 7-tupla aninhada que contém dados populacionais de 1910 a 1970, e uma 3-tupla interna aninhada que contém dados populacionais de 1980 a 2000.

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)

Observações

Também pode usar o método estático Tuple.Create para instanciar um objeto de 8-tuplas (octuplo) sem ter de especificar explicitamente os tipos dos seus componentes. O exemplo seguinte utiliza o Tuple.Create método para instanciar um objeto 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

Isto é equivalente à seguinte chamada ao Tuple<T1,T2,T3,T4,T5,T6,T7> construtor de classes.

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

No entanto, o método estático Tuple.Create não pode ser usado para criar um objeto tupla com mais de oito componentes.

Ao usar o Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> construtor para criar uma n-tupla com oito ou mais componentes, utiliza-se o rest parâmetro para criar uma n-tupla aninhada que tem de um a sete componentes. Ao usar níveis sucessivos de aninhamento, pode criar uma n-tupla que tem um número praticamente ilimitado de componentes. Por exemplo, para criar um 25-tuple, instâncias um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto com três níveis de aninhamento, da seguinte forma:

O objeto mais Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> externo contém os componentes da primeira à sétima. A sua Rest propriedade proporciona acesso a um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto no primeiro nível de aninhamento.
O objeto aninhado Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> mais externo contém os componentes do oitavo ao décimo quarto, e a sua Rest propriedade proporciona acesso a um Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto no segundo nível de aninhamento.
O Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objeto no segundo nível de aninhamento contém os componentes décimo quinto a vigésimo primeiro, e a sua Rest propriedade proporciona acesso a um Tuple<T1,T2,T3,T4> objeto no terceiro nível de aninhamento.
A tupla mais interna é um Tuple<T1,T2,T3,T4> objeto que contém os componentes vigésimo segundo a vigésimo quinto.

Aplica-se a

Ver também

Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)

Comentários

Esta página foi útil?