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

Definice

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

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

Vlastnosti

Metody

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

Viz také

• Tuple
• Tuple<T1>
• Tuple<T1,T2>
• Tuple<T1,T2,T3>
• Tuple<T1,T2,T3,T4>
• Tuple<T1,T2,T3,T4,T5,T6>
• Tuple<T1,T2,T3,T4,T5,T6,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>