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

Definition

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

Typparameter

Vererbung

Object

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

Attribute

SerializableAttribute

Implementiert

IStructuralComparable IStructuralEquatable IComparable ITuple

Hinweise

Ein Tupel ist eine Datenstruktur mit einer bestimmten Anzahl und Reihenfolge von Werten. Die Tuple<T1,T2,T3,T4,T5> Klasse stellt ein 5-Tupel oder ein Quintuple dar, das ein Tupel mit fünf Komponenten ist.

Sie können ein Tuple<T1,T2,T3,T4,T5> Objekt instanziieren, indem Sie entweder den Tuple<T1,T2,T3,T4,T5> Konstruktor oder die statische Tuple.Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5) Methode aufrufen. Sie können den Wert der Komponenten des Tupels mithilfe der schreibgeschützten Item1, Item2, Item3, , Item4, und Item5 Instanzeigenschaften abrufen.

Tuples werden häufig auf vier verschiedene Arten verwendet:

• So stellen Sie eine einzelne Gruppe von Daten dar. Beispielsweise kann ein Tupel einen Datenbankdatensatz darstellen, und seine Komponenten können einzelne Felder des Datensatzes darstellen.

• Um einfachen Zugriff auf und Manipulation von Datensätzen zu ermöglichen. Im folgenden Beispiel wird ein Array von Tuple<T1,T2,T3,T4,T5> Objekten definiert, die die Namen von Running Backs in American Football enthalten, die Anzahl der Spiele, in denen sie gespielt haben, und die Anzahl der Schlepper, gesamter Yards und Touchdowns, die während dieser Spiele erzielt wurden. Das Array wird an die ComputeStatistics Methode übergeben, die die Anzahl der Ausgeführten Pro Spiel, durchschnittliche Yards pro Spiel, durchschnittliche Yards pro Spiel, durchschnittliche Yards pro Tragen und durchschnittliche Anzahl von Touchdowns pro Versuch berechnet.

  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
  

• Um mehrere Werte aus einer Methode zurückzugeben, ohne parameter (in C#) oder ByRef Parametern (in Visual Basic) zu verwendenout. Das vorherige Beispiel gibt beispielsweise seine berechneten Statistiken zusammen mit dem Namen des Spielers in einem Array von Tuple<T1,T2,T3,T4,T5> Objekten zurück.

• So übergeben Sie mehrere Werte an eine Methode über einen einzelnen Parameter. Die Methode verfügt beispielsweise Thread.Start(Object) über einen einzelnen Parameter, mit dem Sie einen Wert für die Methode angeben können, die der Thread beim Start ausführt. Wenn Sie ein Tuple<T1,T2,T3,T4,T5> Objekt als Methodenargument angeben, können Sie die Startroutine des Threads mit fünf Datenelementen angeben.

Konstruktoren

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für

Siehe auch

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