Aracılığıyla paylaş


Tuple<T1,T2,T3,T4,T5> Sınıf

Tanım

5 tanımlama grubu veya beşli grubu temsil eder.

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

Tür Parametreleri

T1

Kayıt düzeninin ilk bileşeninin türü.

T2

Kayıt düzenindeki ikinci bileşenin türü.

T3

Kayıt düzenindeki üçüncü bileşenin türü.

T4

Kayıt düzenindeki dördüncü bileşenin türü.

T5

Kayıt düzeninin beşinci bileşeninin türü.

Devralma
Tuple<T1,T2,T3,T4,T5>
Öznitelikler
Uygulamalar

Açıklamalar

Kayıt düzeni, belirli sayıda ve sıralamadaki değerleri olan bir veri yapısıdır. Tuple<T1,T2,T3,T4,T5> sınıfı, beş bileşeni olan bir tanımlama grubu olan 5 tanımlama grubu veya beşli grubu temsil eder.

Oluşturucuyu veya statik Tuple.Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5) yöntemi çağırarak Tuple<T1,T2,T3,T4,T5> bir Tuple<T1,T2,T3,T4,T5> nesnenin örneğini oluşturabilirsiniz. Salt okunur Item1, , Item2, Item3Item4ve Item5 örnek özelliklerini kullanarak tanımlama grubu bileşenlerinin değerini alabilirsiniz.

Kayıt düzenleri, genellikle dört farklı şekilde kullanılır:

  • Tek bir veri kümesi göstermek için. Örneğin, bir kayıt düzeni, bir veritabanı kaydını temsil edebilir ve bileşenler ise tek tek kaydın alanlarını temsil edebilir.

  • Bir veri kümesine kolay erişim ve düzenleme sağlamak için. Aşağıdaki örnek, Amerikan futbolundaki yedeklerin adlarını, oynadıkları oyun sayısını ve bu oyunlar sırasında atılan taşıma sayısını, kazanılan toplam yardaları ve touchdown'ları içeren bir nesne dizisini Tuple<T1,T2,T3,T4,T5> tanımlar. Dizi yöntemine ComputeStatistics geçirilir. Bu yöntem, her bir koşunun oyun başına taşıma sayısını, oyun başına ortalama yarda sayısını, taşıma başına ortalama yarda sayısını ve girişim başına ortalama touchdown sayısını hesaplar.

    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
    
  • Parametre (C#'da) veya ByRef parametre (Visual Basic içinde) kullanmadan out bir yöntemden birden çok değer döndürmek için. Örneğin, önceki örnek bir nesne dizisinde Tuple<T1,T2,T3,T4,T5> oyuncunun adıyla birlikte hesaplanan istatistiklerini döndürür.

  • Birden çok değeri tek bir parametre ile bir yönteme geçirmek için. Örneğin, yönteminin, iş parçacığının Thread.Start(Object) başlangıçta yürüttüğü yönteme bir değer sağlamanıza olanak tanıyan tek bir parametresi vardır. Yöntem bağımsız değişkeni olarak bir Tuple<T1,T2,T3,T4,T5> nesne sağlarsanız, iş parçacığının başlangıç yordamını beş veri öğesiyle sağlayabilirsiniz.

Oluşturucular

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

Tuple<T1,T2,T3,T4,T5> sınıfının yeni bir örneğini başlatır.

Özellikler

Item1

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin ilk bileşeninin değerini alır.

Item2

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin ikinci bileşeninin değerini alır.

Item3

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin üçüncü bileşeninin değerini alır.

Item4

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin dördüncü bileşeninin değerini alır.

Item5

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin beşinci bileşeninin değerini alır.

Yöntemler

Equals(Object)

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.

GetHashCode()

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin karma kodunu döndürür.

GetType()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
ToString()

Bu Tuple<T1,T2,T3,T4,T5> örneğin değerini temsil eden bir dize döndürür.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Geçerli Tuple<T1,T2,T3,T4,T5> nesneyi belirtilen bir nesneyle karşılaştırır ve geçerli nesnenin sıralama düzeninde belirtilen nesneden önce mi, sonra mı yoksa belirtilen nesneyle aynı konumda mı olduğunu belirten bir tamsayı döndürür.

IStructuralComparable.CompareTo(Object, IComparer)

Belirtilen bir karşılaştırıcı kullanarak geçerli Tuple<T1,T2,T3,T4,T5> nesneyi belirtilen bir nesneyle karşılaştırır ve geçerli nesnenin sıralama düzeninde belirtilen nesneyle aynı konumda mı, ondan önce mi, sonra mı yoksa aynı konumda mı olduğunu belirten bir tamsayı döndürür.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Geçerli Tuple<T1,T2,T3,T4,T5> nesnenin belirtilen bir karşılaştırma yöntemine göre belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Belirtilen bir hesaplama yöntemini kullanarak geçerli Tuple<T1,T2,T3,T4,T5> nesnenin karma kodunu hesaplar.

ITuple.Item[Int32]

Belirtilen Tuple öğenin değerini alır.

ITuple.Length

içindeki Tupleöğe sayısını alır.

Uzantı Metotları

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

5 öğeli bir tanımlama kümesini ayrı değişkenlere ayırır.

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

sınıfının bir örneğini Tuple yapı örneğine ValueTuple dönüştürür.

Şunlara uygulanır

Ayrıca bkz.