Udostępnij za pośrednictwem


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

Definicja

Reprezentuje krotkę 5-krotkową lub kwintuple.

generic <typename T1, typename T2, typename T3, typename T4, typename T5>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
generic <typename T1, typename T2, typename T3, typename T4, typename T5>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple
public class Tuple<T1,T2,T3,T4,T5> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
public class Tuple<T1,T2,T3,T4,T5> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple
[System.Serializable]
public class Tuple<T1,T2,T3,T4,T5> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple
[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple
Public Class Tuple(Of T1, T2, T3, T4, T5)
Implements IComparable, IStructuralComparable, IStructuralEquatable
Public Class Tuple(Of T1, T2, T3, T4, T5)
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.

Dziedziczenie
Tuple<T1,T2,T3,T4,T5>
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> reprezentuje krotkę 5-krotkową lub kwintuple, która jest krotką zawierającą pięć składników.

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

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. W poniższym przykładzie zdefiniowano tablicę Tuple<T1,T2,T3,T4,T5> obiektów, które zawierają nazwy uruchomionych pleców w amerykańskiej piłce nożnej, liczbę gier, w których grali, a liczba prowadzi, łączna liczba przyłożenia uzyskanych i przyłożenia strzelonych podczas tych gier. Tablica jest przekazywana do ComputeStatistics metody, która oblicza liczbę prowadzi z powrotem na grę, średnie stocznie na grę, średnie stocznie na prowadzenie i średnią liczbę przyłożenia na próbę.

    using System;
    using System.Collections.Generic;
    
    public class Example
    {
       public static void Main()
       {
          // Organization of runningBacks 5-tuple:
          //    Component 1: Player name
          //    Component 2: Number of games played
          //    Component 3: Number of attempts (carries)
          //    Component 4: Number of yards gained 
          //    Component 5: Number of touchdowns   
          Tuple<string, int, int, int, int>[] runningBacks =
               { Tuple.Create("Payton, Walter", 190, 3838, 16726, 110),  
                 Tuple.Create("Sanders, Barry", 153, 3062, 15269, 99),            
                 Tuple.Create("Brown, Jim", 118, 2359, 12312, 106),            
                 Tuple.Create("Dickerson, Eric", 144, 2996, 13259, 90),            
                 Tuple.Create("Faulk, Marshall", 176, 2836, 12279, 100) }; 
          // Calculate statistics.
          // Organization of runningStats 5-tuple:
          //    Component 1: Player name
          //    Component 2: Number of attempts per game
          //    Component 3: Number of yards per game
          //    Component 4: Number of yards per attempt 
          //    Component 5: Number of touchdowns per attempt   
          Tuple<string, double, double, double, double>[] runningStats  = 
              ComputeStatistics(runningBacks);
    
          // Display the result.          
          Console.WriteLine("{0,-16} {1,5} {2,6} {3,7} {4,7} {5,7} {6,7} {7,5} {8,7}\n", 
                            "Name", "Games", "Att", "Att/Gm", "Yards", "Yds/Gm",
                            "Yds/Att", "TD", "TD/Att");
          for (int ctr = 0; ctr < runningBacks.Length; ctr++)
             Console.WriteLine("{0,-16} {1,5} {2,6:N0} {3,7:N1} {4,7:N0} {5,7:N1} {6,7:N2} {7,5} {8,7:N3}\n", 
                               runningBacks[ctr].Item1, runningBacks[ctr].Item2, runningBacks[ctr].Item3, 
                               runningStats[ctr].Item2, runningBacks[ctr].Item4, runningStats[ctr].Item3, 
                               runningStats[ctr].Item4, runningBacks[ctr].Item5, runningStats[ctr].Item5);
       }
    
       private static Tuple<string, double, double, double, double>[] ComputeStatistics(
                    Tuple<string, int, int, int, int>[] players) 
       {
          Tuple<string, double, double, double, double> result; 
          var list = new List<Tuple<string, double, double, double, double>>();
          
          foreach (var player in players)
          {
             // Create result object containing player name and statistics.
             result = Tuple.Create(player.Item1,  
                                   player.Item3/((double)player.Item2), 
                                   player.Item4/((double)player.Item2),
                                   player.Item4/((double)player.Item3), 
                                   player.Item5/((double)player.Item3));
             list.Add(result);         
          }
          return list.ToArray();  
       }
    }
    // The example displays the following output:
    //    Name             Games    Att  Att/Gm   Yards  Yds/Gm Yds/Att    TD  TD/Att
    //    
    //    Payton, Walter     190  3,838    20.2  16,726    88.0    4.36   110   0.029
    //    
    //    Sanders, Barry     153  3,062    20.0  15,269    99.8    4.99    99   0.032
    //    
    //    Brown, Jim         118  2,359    20.0  12,312   104.3    5.22   106   0.045
    //    
    //    Dickerson, Eric    144  2,996    20.8  13,259    92.1    4.43    90   0.030
    //    
    //    Faulk, Marshall    176  2,836    16.1  12,279    69.8    4.33   100   0.035
    
    open System
    
    let computeStatistics (players: Tuple<string, int, int, int, int>[]) = 
        [| for player in players do
            // Create result object containing player name and statistics.
            Tuple.Create(player.Item1,  
                         double player.Item3 / double player.Item2,
                         double player.Item4 / double player.Item2,
                         double player.Item4 / double player.Item3, 
                         double player.Item5 / double player.Item3) |]
    
    
    // Organization of runningBacks 5-tuple:
    //    Component 1: Player name
    //    Component 2: Number of games played
    //    Component 3: Number of attempts (carries)
    //    Component 4: Number of yards gained 
    //    Component 5: Number of touchdowns   
    let runningBacks =
        [| Tuple.Create("Payton, Walter", 190, 3838, 16726, 110)
           Tuple.Create("Sanders, Barry", 153, 3062, 15269, 99)
           Tuple.Create("Brown, Jim", 118, 2359, 12312, 106)
           Tuple.Create("Dickerson, Eric", 144, 2996, 13259, 90)
           Tuple.Create("Faulk, Marshall", 176, 2836, 12279, 100) |]
    // Calculate statistics.
    // Organization of runningStats 5-tuple:
    //    Component 1: Player name
    //    Component 2: Number of attempts per game
    //    Component 3: Number of yards per game
    //    Component 4: Number of yards per attempt 
    //    Component 5: Number of touchdowns per attempt   
    let runningStats = computeStatistics runningBacks
    
    // Display the result.          
    printfn "%-16s %5s %6s %7s %7s %7s %7s %5s %7s\n" "Name" "Games" "Att" "Att/Gm" "Yards" "Yds/Gm" "Yds/Att" "TD" "TD/Att"
    for i = 0 to runningBacks.Length - 1 do
        printfn $"{runningBacks[i].Item1,-16} {runningBacks[i].Item2,5} {runningBacks[i].Item3,6:N0} {runningBacks[i].Item2,7:N1} {runningBacks[i].Item4,7:N0} {runningBacks[i].Item3,7:N1} {runningBacks[i].Item4,7:N2} {runningBacks[i].Item5,5} {runningBacks[i].Item5,7:N3}\n" 
    
    // The example displays the following output:
    //    Name             Games    Att  Att/Gm   Yards  Yds/Gm Yds/Att    TD  TD/Att
    //    
    //    Payton, Walter     190  3,838    20.2  16,726    88.0    4.36   110   0.029
    //    
    //    Sanders, Barry     153  3,062    20.0  15,269    99.8    4.99    99   0.032
    //    
    //    Brown, Jim         118  2,359    20.0  12,312   104.3    5.22   106   0.045
    //    
    //    Dickerson, Eric    144  2,996    20.8  13,259    92.1    4.43    90   0.030
    //    
    //    Faulk, Marshall    176  2,836    16.1  12,279    69.8    4.33   100   0.035
    
    Imports System.Collections.Generic
    
    Module Example
       Public Sub Main()
          ' Organization of runningBacks 5-tuple:
          '    Component 1: Player name
          '    Component 2: Number of games played
          '    Component 3: Number of attempts (carries)
          '    Component 4: Number of yards gained 
          '    Component 5: Number of touchdowns   
          Dim runningBacks() =
              { Tuple.Create("Payton, Walter", 190, 3838, 16726, 110),  
                Tuple.Create("Sanders, Barry", 153, 3062, 15269, 99),            
                Tuple.Create("Brown, Jim", 118, 2359, 12312, 106),            
                Tuple.Create("Dickerson, Eric", 144, 2996, 13259, 90),            
                Tuple.Create("Faulk, Marshall", 176, 2836, 12279, 100) } 
          ' Calculate statistics.
          ' Organization of runningStats 5-tuple:
          '    Component 1: Player name
          '    Component 2: Number of attempts per game
          '    Component 3: Number of yards per game
          '    Component 4: Number of yards per attempt 
          '    Component 5: Number of touchdowns per attempt   
          Dim runningStats() = ComputeStatistics(runningBacks)
    
          ' Display the result.          
          Console.WriteLine("{0,-16} {1,5} {2,6} {3,7} {4,7} {5,7} {6,7} {7,5} {8,7}", 
                            "Name", "Games", "Att", "Att/Gm", "Yards", "Yds/Gm",
                            "Yds/Att", "TD", "TD/Att")
          Console.WriteLine()
          For ctr As Integer = 0 To runningBacks.Length - 1
             Console.WriteLine("{0,-16} {1,5} {2,6:N0} {3,7:N1} {4,7:N0} {5,7:N1} {6,7:N2} {7,5} {8,7:N3}", 
                               runningBacks(ctr).Item1, runningBacks(ctr).Item2, runningBacks(ctr).Item3, 
                               runningStats(ctr).Item2, runningBacks(ctr).Item4, runningStats(ctr).Item3, 
                               runningStats(ctr).Item4, runningBacks(ctr).Item5, runningStats(ctr).Item5)
             Console.WriteLine()  
          Next     
       End Sub
    
       Private Function ComputeStatistics(players() As Tuple(Of String, Integer, Integer, Integer, Integer)) _
                        As Tuple(Of String, Double, Double, Double, Double)()
    
          Dim result As Tuple(Of String, Double, Double, Double, Double)
          Dim list As New List(Of Tuple(Of String, Double, Double, Double, Double))()
          
          For Each player In players
             ' Create result object containing player name and statistics.
             result = Tuple.Create(player.Item1,  
                                player.Item3/player.Item2, player.Item4/player.Item2,
                                player.Item4/player.Item3, player.Item5/player.Item3)
             list.Add(result)         
          Next
          Return list.ToArray()  
       End Function
    End Module
    ' The example displays the following output:
    '    Name             Games    Att  Att/Gm   Yards  Yds/Gm Yds/Att    TD  TD/Att
    '    
    '    Payton, Walter     190  3,838    20.2  16,726    88.0    4.36   110   0.029
    '    
    '    Sanders, Barry     153  3,062    20.0  15,269    99.8    4.99    99   0.032
    '    
    '    Brown, Jim         118  2,359    20.0  12,312   104.3    5.22   106   0.045
    '    
    '    Dickerson, Eric    144  2,996    20.8  13,259    92.1    4.43    90   0.030
    '    
    '    Faulk, Marshall    176  2,836    16.1  12,279    69.8    4.33   100   0.035
    
  • 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ą odtwarzacza w tablicy Tuple<T1,T2,T3,T4,T5> obiektów.

  • 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> uruchamiania wątku z pięcioma elementami danych.

Konstruktory

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

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

Właściwości

Item1

Pobiera wartość pierwszego składnika bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

Item2

Pobiera wartość drugiego składnika bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

Item3

Pobiera wartość trzeciego składnika bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

Item4

Pobiera wartość czwartego składnika bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

Item5

Pobiera wartość piątego składnika bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

Metody

Equals(Object)

Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2,T3,T4,T5> obiekt jest równy określonemu obiektowi.

GetHashCode()

Zwraca kod skrótu dla bieżącego Tuple<T1,T2,T3,T4,T5> obiektu.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(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> wystąpienia.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje bieżący Tuple<T1,T2,T3,T4,T5> 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> 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> 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> 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>(Tuple<T1,T2,T3,T4,T5>, T1, T2, T3, T4, T5)

Dekonstruktoruje krotkę z 5 elementami na oddzielne zmienne.

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

Konwertuje wystąpienie Tuple klasy na wystąpienie ValueTuple struktury.

Dotyczy

Zobacz też