Tuple<T1,T2,T3,T4,T5,T6> Třída

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Tuple.cs

Představuje 6 členů nebo sextuple.

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.Runtime.CompilerServices.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, ITuple

Parametry typu

T1

Typ první komponenty řazené kolekce členů.

T2

Typ druhé komponenty řazené kolekce členů.

T3

Typ třetí komponenty řazené kolekce členů.

T4

Typ čtvrté komponenty řazené kolekce členů.

T5

Typ páté komponenty řazené kolekce členů.

T6

Typ šesté součásti řazené kolekce členů.

Dědičnost

Object

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

Implementuje

IStructuralComparable IStructuralEquatable IComparable ITuple

Poznámky

Řazená kolekce členů je datová struktura, která má určitý počet a posloupnost hodnot. Třída Tuple<T1,T2,T3,T4,T5,T6> představuje 6 členů nebo sextuple, což je řazená kolekce členů, která má šest součástí.

Vytvoření instance objektu Tuple<T1,T2,T3,T4,T5,T6> můžete vytvořit voláním statické Tuple<T1,T2,T3,T4,T5,T6> metody nebo Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) metody. Hodnotu komponent řazené kolekce členů můžete načíst pomocí vlastností jen pro čtení Item1, Item2, Item3, Item4, Item5a Item6 instance.

Řazené kolekce členů se běžně používají čtyřmi různými způsoby:

• Představuje jednu sadu dat. Například řazená kolekce členů může představovat záznam databáze a její komponenty mohou představovat jednotlivá pole záznamu.

• Pro zajištění snadného přístupu k datové sadě a manipulaci s nimi. Následující příklad definuje Tuple<T1,T2,T3,T4,T5,T6> objekt, který obsahuje data populace pro New York City pro každý sčítání lidu z roku 1960 do roku 2000. Sextuple se předá ComputePopulationChange metodě, která vypočítá roční míru změny mezi sčítáním lidu a roční sazbou změn pro celé 50leté období.

  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 %
  

• Chcete-li vrátit více hodnot z metody bez použití out parametrů (v jazyce C#) nebo ByRef parametrů (v jazyce Visual Basic). Například předchozí příklad vrátí vypočítanou statistiku spolu s názvem města v objektu Tuple<T1,T2,T3,T4,T5,T6> .

• Předání více hodnot metodě prostřednictvím jednoho parametru. Například Thread.Start(Object) metoda má jeden parametr, který umožňuje zadat jednu hodnotu metodě, kterou vlákno spouští při spuštění. Pokud jako argument metody zadáte Tuple<T1,T2,T3,T4,T5,T6> objekt, můžete zadat spouštěcí rutinu vlákna se šesti položkami dat.

Konstruktory

Name	Description
Tuple<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Inicializuje novou instanci Tuple<T1,T2,T3,T4,T5,T6> třídy.

Vlastnosti

Name	Description
Item1	Získá hodnotu první komponenty aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu.
Item2	Získá hodnotu druhé komponenty aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu.
Item3	Získá hodnotu třetí komponenty aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu.
Item4	Získá hodnotu čtvrté komponenty aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu.
Item5	Získá hodnotu páté komponenty aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu.
Item6	Získá hodnotu aktuálního Tuple<T1,T2,T3,T4,T5,T6> objektu šestá komponenta.

Metody

Name	Description
Equals(Object)	Vrátí hodnotu, která určuje, zda je aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt roven zadanému objektu.
GetHashCode()	Vrátí kód hash pro aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt.
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vrátí řetězec, který představuje hodnotu této Tuple<T1,T2,T3,T4,T5,T6> instance.

Explicitní implementace rozhraní

Name	Description
IComparable.CompareTo(Object)	Porovná aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt se zadaným objektem a vrátí celé číslo, které určuje, zda je aktuální objekt před, za nebo ve stejné pozici jako zadaný objekt v pořadí řazení.
IStructuralComparable.CompareTo(Object, IComparer)	Porovná aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt se zadaným objektem pomocí zadaného porovnávače a vrátí celé číslo, které určuje, zda je aktuální objekt před, za nebo ve stejné pozici jako zadaný objekt v pořadí řazení.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Vrátí hodnotu, která určuje, zda je aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt roven zadanému objektu na základě zadané metody porovnání.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Vypočítá kód hash pro aktuální Tuple<T1,T2,T3,T4,T5,T6> objekt pomocí zadané výpočetní metody.
ITuple.Item[Int32]	Získá hodnotu zadaného Tuple prvku.
ITuple.Length	Získá počet prvků v .Tuple

Metody rozšíření

Name	Description
Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Dekonstruuje řazenou kolekci členů se 6 elementy do samostatných proměnných.
ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)	Převede instanci Tuple třídy na instanci ValueTuple struktury.

Viz také

• 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,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>