Udostępnij za pośrednictwem


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

Definicja

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
Tuple<T1,T2,T3,T4,T5,T6>
Atrybuty
Implementuje

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, Item3Item4, , 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

Zobacz też