Tuple<T1,T2,T3,T4,T5> Класс

Определение

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

Параметры типа

Наследование

Object

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

Атрибуты

SerializableAttribute

Реализации

IStructuralComparable IStructuralEquatable IComparable ITuple

Комментарии

Кортеж — это структура данных, которая имеет определенное число и последовательность значений. Класс Tuple<T1,T2,T3,T4,T5> представляет 5 кортежей или квинтул, который представляет собой кортеж, имеющий пять компонентов.

Можно создать экземпляр Tuple<T1,T2,T3,T4,T5> объекта, вызвав Tuple<T1,T2,T3,T4,T5> конструктор или статический Tuple.Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5) метод. Значение компонентов кортежа можно получить с помощью свойств экземпляра, доступных только Item1для чтения, Item2и Item3Item4Item5 экземпляров.

Кортежи обычно используются четырьмя разными способами:

• Представление одного набора данных. Например, кортеж может представлять запись базы данных, а ее компоненты могут представлять отдельные поля записи.

• Чтобы обеспечить простой доступ к набору данных и их обработке. В следующем примере определяется массив Tuple<T1,T2,T3,T4,T5> объектов, содержащих имена бегущей спины в американском футболе, количество игр, в которых они играли, и количество переносок, общее количество ярдов, полученных, и приземления забили во время этих игр. Массив передается методу ComputeStatistics , который вычисляет количество каждого бегущей спины на игру, средние ярды на игру, средние ярды на переноску и среднее число приземления на попытку.

  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
  

• Чтобы вернуть несколько значений из метода без использования out параметров (в C#) или ByRef параметров (в Visual Basic). Например, предыдущий пример возвращает вычисляемую статистику вместе с именем проигрывателя в массиве Tuple<T1,T2,T3,T4,T5> объектов.

• Передача нескольких значений методу через один параметр. Например, метод Thread.Start(Object) имеет один параметр, который позволяет указать одно значение методу, который выполняется потоком при запуске. Если вы предоставляете Tuple<T1,T2,T3,T4,T5> объект в качестве аргумента метода, вы можете предоставить подпрограмму запуска потока пятью элементами данных.

См. также раздел

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