Tuple<T1,T2,T3,T4,T5,T6> 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 um 6-tuplo, ou sextuplo.

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

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

public class Tuple<T1,T2,T3,T4,T5,T6> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

[System.Serializable]
public class Tuple<T1,T2,T3,T4,T5,T6> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

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

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

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

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

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

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

Public Class Tuple(Of T1, T2, T3, T4, T5, T6)
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.

Herança: Object
Tuple<T1,T2,T3,T4,T5,T6>

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> classe representa uma 6-tupla, ou sextupla, que é uma tupla com seis componentes.

Pode instanciar um Tuple<T1,T2,T3,T4,T5,T6> objeto chamando o Tuple<T1,T2,T3,T4,T5,T6> ou o método estático Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) . Pode recuperar o valor dos componentes da tupla usando as propriedades de apenas Item1leitura , Item2, Item3, Item4 Item5, , e Item6 instância.

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. O exemplo seguinte define um Tuple<T1,T2,T3,T4,T5,T6> objeto que contém dados populacionais da cidade de Nova Iorque para cada censo de 1960 a 2000. O sextuplo é passado para o ComputePopulationChange método, que calcula a taxa anual de variação entre censos, bem como a taxa anual de variação para todo o período de 50 anos.

using System;

public class Example
{
   public static void Main()
   {
      // Get population data for New York City, 1960-2000.
      var population = 
           Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278);
      var rate = ComputePopulationChange(population);
      // Display results.
      Console.WriteLine("Population Change, {0}, 1960-2000\n", population.Item1);
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
      Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA");
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
      Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50);
   }

   private static Tuple<string, double, double, double, double, double> ComputePopulationChange(
           Tuple<string, int, int, int, int, int> data)  
   {           
      var rate = Tuple.Create(data.Item1, 
                              (double)(data.Item3 - data.Item2)/data.Item2, 
                              (double)(data.Item4 - data.Item3)/data.Item3, 
                              (double)(data.Item5 - data.Item4)/data.Item4, 
                              (double)(data.Item6 - data.Item5)/data.Item5,
                              (double)(data.Item6 - data.Item2)/data.Item2 );
      return rate;
   }           
}
// The example displays the following output:
//       Population Change, New York, 1960-2000
//       
//       Year      Population Annual Rate
//       1960       7,781,984          NA
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1960-2000                 0.06 %

open System

let computePopulationChange (data: Tuple<string, int, int, int, int, int>) =  
    Tuple.Create(data.Item1, 
                 double ((data.Item3 - data.Item2) / data.Item2), 
                 double ((data.Item4 - data.Item3) / data.Item3), 
                 double ((data.Item5 - data.Item4) / data.Item4), 
                 double ((data.Item6 - data.Item5) / data.Item5),
                 double ((data.Item6 - data.Item2) / data.Item2))

// Get population data for New York City, 1960-2000.
let population = 
      Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278)
let rate = computePopulationChange population
// Display results.
printfn $"Population Change, {population.Item1}, 1960-2000\n"
printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
printfn $"""1960      {population.Item2,10:N0} {"NA",11}"""
printfn $"1970      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
printfn $"1980      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}"
printfn $"1990      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}"
printfn $"2000      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}"
printfn $"""1960-2000 {"",10:N0} {rate.Item6 / 50.,11:P2}"""

// The example displays the following output:
//       Population Change, New York, 1960-2000
//       
//       Year      Population Annual Rate
//       1960       7,781,984          NA
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1960-2000                 0.06 %

Module Example
   Public Sub Main()
      ' Get population data for New York City, 1960-2000.
      Dim population = Tuple.Create(
                     "New York", 7781984, 7894862, 7071639, 7322564, 8008278)
      Dim rate = ComputePopulationChange(population)      
      ' Display results.
      Console.WriteLine("Population Change, {0}, 1960-2000", population.Item1)
      Console.WriteLine()
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
      Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA")
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
      Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50)
   End Sub
   
      ' Compute rate of population change by decade and overall.
   Private Function ComputePopulationChange(data As Tuple(Of String, Integer, Integer, Integer, Integer, Integer)) _ 
           As Tuple(Of String, Double, Double, Double, Double, Double)
      Dim rate = Tuple.Create(data.Item1, 
                              (data.Item3 - data.Item2)/data.Item2, 
                              (data.Item4 - data.Item3)/data.Item3, 
                              (data.Item5 - data.Item4)/data.Item4, 
                              (data.Item6 - data.Item5)/data.Item5,
                              (data.Item6 - data.Item2)/data.Item2 )
      Return rate
   End Function           
End Module
' The example displays the following output:
'       Population Change, New York, 1960-2000
'       
'       Year      Population Annual Rate
'       1960       7,781,984          NA
'       1970       7,894,862      0.15 %
'       1980       7,071,639     -1.04 %
'       1990       7,322,564      0.35 %
'       2000       8,008,278      0.94 %
'       1960-2000                 0.06 %

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> 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> objeto como argumento de método, pode fornecer a rotina de arranque do thread com seis itens de dados.

Construtores

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

Propriedades

Name	Description
Item1	Obtém o valor do primeiro componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
Item2	Obtém o valor do segundo componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
Item3	Obtém o valor do terceiro componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
Item4	Obtém o valor do quarto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
Item5	Obtém o valor do quinto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
Item6	Obtém o valor do sexto componente do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .

Métodos

Name	Description
Equals(Object)	Devolve um valor que indica se o objeto atual Tuple<T1,T2,T3,T4,T5,T6> é igual a um objeto especificado.
GetHashCode()	Devolve o código hash do objeto atual Tuple<T1,T2,T3,T4,T5,T6> .
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> instância.

Implementações de Interface Explícita

Name	Description
IComparable.CompareTo(Object)	Compara o objeto atual Tuple<T1,T2,T3,T4,T5,T6> 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> 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> é 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> 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`

Métodos da Extensão

Name	Description
Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Desconstrói uma tupla com 6 elementos em variáveis separadas.
ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)	Converte uma instância da `Tuple` classe numa instância da `ValueTuple` estrutura.

Aplica-se a

Ver também

Comentários

Esta página foi útil?