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

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Reprezentuje krotkę 6-krotkową lub sekstuple.

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

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

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

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

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

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

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

Parametry typu

T1

Typ pierwszego składnika spójnej kolekcji.

T2

Typ drugiego składnika spójnej kolekcji.

T3

Typ trzeciego składnika spójnej kolekcji.

T4

Typ czwartego składnika spójnej kolekcji.

T5

Typ piątego składnika spójnej kolekcji.

T6

Typ szóstego składnika krotki.

Dziedziczenie: Object
Tuple<T1,T2,T3,T4,T5,T6>

Atrybuty: SerializableAttribute

Implementuje: IStructuralComparable IStructuralEquatable IComparable ITuple

Uwagi

Spójna kolekcja to struktura danych, która ma określoną liczbę i kolejność wartości. Klasa Tuple<T1,T2,T3,T4,T5,T6> reprezentuje krotkę 6-krotkową lub sekstuple, która jest krotką zawierającą sześć składników.

Wystąpienie obiektu można utworzyć, wywołując metodę Tuple<T1,T2,T3,T4,T5,T6> statyczną Tuple<T1,T2,T3,T4,T5,T6>Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) lub . Wartość składników krotki można pobrać przy użyciu właściwości wystąpienia tylko Item1do odczytu, Item2, Item3 Item4, , Item5i Item6 .

Spójne kolekcje są powszechnie wykorzystywane na cztery różne sposoby:

Reprezentowanie jednego zestawu danych. Na przykład spójna kolekcja może reprezentować rekord bazy danych, a jej składniki mogą reprezentować poszczególne pola rekordu.

Zapewnienie łatwego dostępu do zestawu danych i możliwości wykonywania w nim różnych operacji. Poniższy przykład definiuje Tuple<T1,T2,T3,T4,T5,T6> obiekt, który zawiera dane populacji dla Nowego Jorku dla każdego spisu z 1960 do 2000 roku. Sekstuple jest przekazywany do ComputePopulationChange metody, która oblicza roczną stopę zmian między spisami, a także roczną stopą zmian przez cały okres 50 lat.

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 %

Aby zwrócić wiele wartości z metody bez użycia parametrów out (w języku C#) lub ByRef parametrów (w Visual Basic). Na przykład poprzedni przykład zwraca obliczone statystyki wraz z nazwą miasta w Tuple<T1,T2,T3,T4,T5,T6> obiekcie.
Przekazywanie wielu wartości do metody za pomocą jednego parametru. Na przykład Thread.Start(Object) metoda ma jeden parametr, który umożliwia podanie jednej wartości do metody wykonywanej przez wątek podczas uruchamiania. Jeśli podasz obiekt jako argument metody, możesz podać procedurę Tuple<T1,T2,T3,T4,T5,T6> uruchamiania wątku z sześcioma elementami danych.

Konstruktory

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

Inicjuje nowe wystąpienie klasy Tuple<T1,T2,T3,T4,T5,T6>.

Właściwości

Item1	Pobiera wartość pierwszego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
Item2	Pobiera wartość drugiego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
Item3	Pobiera wartość trzeciego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
Item4	Pobiera wartość czwartego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
Item5	Pobiera wartość piątego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
Item6	Pobiera wartość szóstego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.

Metody

Equals(Object)	Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2,T3,T4,T5,T6> obiekt jest równy określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu.
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca ciąg reprezentujący wartość tego Tuple<T1,T2,T3,T4,T5,T6> wystąpienia.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)	Porównuje bieżący Tuple<T1,T2,T3,T4,T5,T6> obiekt z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy bieżący obiekt znajduje się przed, po, czy w tej samej pozycji co określony obiekt w kolejności sortowania.
IStructuralComparable.CompareTo(Object, IComparer)	Porównuje bieżący Tuple<T1,T2,T3,T4,T5,T6> obiekt z określonym obiektem przy użyciu określonego porównania i zwraca liczbę całkowitą wskazującą, czy bieżący obiekt znajduje się przed, po, czy w tej samej pozycji co określony obiekt w kolejności sortowania.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2,T3,T4,T5,T6> obiekt jest równy określonemu obiektowi na podstawie określonej metody porównania.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Oblicza kod skrótu dla bieżącego Tuple<T1,T2,T3,T4,T5,T6> obiektu przy użyciu określonej metody obliczeniowej.
ITuple.Item[Int32]	Pobiera wartość określonego `Tuple` elementu.
ITuple.Length	Pobiera liczbę elementów w elemecie `Tuple`.

Metody rozszerzania

Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Dekonstruktoruje krotkę z 6 elementami na oddzielne zmienne.
ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)	Konwertuje wystąpienie `Tuple` klasy na wystąpienie `ValueTuple` struktury.

Dotyczy