Sdílet prostřednictvím


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

Definice

Představuje 5 řazenou kolekci členů nebo kvintu.

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 první součásti řazené kolekce členů.

T2

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

T3

Typ třetí součásti řazené kolekce členů.

T4

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

T5

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

Dědičnost
Tuple<T1,T2,T3,T4,T5>
Atributy
Implementuje

Poznámky

Řazená kolekce členů je datová struktura, která obsahuje určitý počet a pořadí hodnot. Třída Tuple<T1,T2,T3,T4,T5> představuje 5 členů nebo quintuple, což je řazená kolekce členů, která má pět komponent.

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

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

  • K reprezentaci jediné datové sady. Například řazená kolekce členů může představovat záznam v databázi a její součásti mohou představovat jednotlivá pole záznamu.

  • K zajištění snadného přístupu k datové sadě a manipulace s datovou sadou. Následující příklad definuje řadu Tuple<T1,T2,T3,T4,T5> objektů, které obsahují názvy běhů v americkém fotbale, počet her, ve kterých hráli, a počet her, celkový počet získaných yardů a touchdowny, které se během těchto zápasů vyhodnotovaly. Pole se předává metodě ComputeStatistics , která vypočítá počet přenášených zad na hru, průměrné yardy na hru, průměrné yardy na nos a průměrný počet touchdownů na pokus.

    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
    
  • Chcete-li vrátit více hodnot z metody bez použití out parametrů (v jazyce C#) nebo ByRef parametrů (v Visual Basic). Předchozí příklad například vrátí vypočítanou statistiku spolu s názvem hráče v matici Tuple<T1,T2,T3,T4,T5> objektů.

  • Pro předání více hodnot metodě prostřednictvím jediného parametru. Například metoda má jeden parametr, Thread.Start(Object) 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> objekt, můžete zadat spouštěcí rutinu vlákna s pěti položkami dat.

Konstruktory

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

Inicializuje novou instanci Tuple<T1,T2,T3,T4,T5> třídy.

Vlastnosti

Item1

Získá hodnotu první komponenty aktuálního Tuple<T1,T2,T3,T4,T5> objektu.

Item2

Získá hodnotu druhé komponenty aktuálního Tuple<T1,T2,T3,T4,T5> objektu.

Item3

Získá hodnotu aktuálního Tuple<T1,T2,T3,T4,T5> objektu třetí komponenty.

Item4

Získá hodnotu aktuálního Tuple<T1,T2,T3,T4,T5> objektu čtvrté součásti.

Item5

Získá hodnotu aktuálního Tuple<T1,T2,T3,T4,T5> objektu páté součásti.

Metody

Equals(Object)

Vrátí hodnotu, která označuje, zda je aktuální Tuple<T1,T2,T3,T4,T5> objekt roven zadanému objektu.

GetHashCode()

Vrátí kód hash pro aktuální Tuple<T1,T2,T3,T4,T5> objekt.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
ToString()

Vrátí řetězec, který představuje hodnotu této Tuple<T1,T2,T3,T4,T5> instance.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná aktuální Tuple<T1,T2,T3,T4,T5> objekt se zadaným objektem a vrátí celé číslo, které označ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> objekt se zadaným objektem pomocí zadaného porovnávače a vrátí celé číslo, které označ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> 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> 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í

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

Dekonstruuje řazenou kolekci členů s 5 prvky do samostatných proměnných.

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

Převede instanci Tuple třídy na instanci ValueTuple struktury.

Platí pro

Viz také