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

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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: Object
Tuple<T1,T2,T3,T4,T5>

Atributy: SerializableAttribute

Implementuje: IStructuralComparable IStructuralEquatable IComparable ITuple

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, Item3 Item4a 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