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

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kodlar:: mscorlib.dll, System.Runtime.dll

Bütünleştirilmiş Kodlar:: netstandard.dll, System.Runtime.dll

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: Tuple.cs

Kaynak:: Tuple.cs

Kaynak:: Tuple.cs

Kaynak:: Tuple.cs

Kaynak:: Tuple.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

4 tanımlama grubu veya dörtlü bir grubu temsil eder.

generic <typename T1, typename T2, typename T3, typename T4>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

generic <typename T1, typename T2, typename T3, typename T4>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple

public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

[System.Serializable]
public class Tuple<T1,T2,T3,T4> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable

type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple

Public Class Tuple(Of T1, T2, T3, T4)
Implements IComparable, IStructuralComparable, IStructuralEquatable

Public Class Tuple(Of T1, T2, T3, T4)
Implements IComparable, IStructuralComparable, IStructuralEquatable, ITuple

Tür Parametreleri

T1

Tanımlama grubunun ilk bileşeninin türü.

T2

Tanımlama grubunun ikinci bileşeninin türü.

T3

Tanımlama grubunun üçüncü bileşeninin türü.

T4

Tanımlama grubunun dördüncü bileşeninin türü.

Devralma: Object
Tuple<T1,T2,T3,T4>

Öznitelikler: SerializableAttribute

Uygulamalar: IStructuralComparable IStructuralEquatable IComparable ITuple

Açıklamalar

Tanımlama grubu, belirli bir değer sayısına ve dizisine sahip bir veri yapısıdır. Tuple<T1,T2,T3,T4> sınıfı, dört bileşeni olan bir tanımlama grubu olan 4 tanımlama grubu veya dörtlü bir tanımlama grubudur.

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

Tanımlama demetleri yaygın olarak dört farklı şekilde kullanılır:

Tek bir veri kümesini temsil etmek için. Örneğin, bir tanımlama grubu bir veritabanı kaydını temsil edebilir ve bileşenleri kaydın tek tek alanlarını temsil edebilir.

Bir veri kümesine kolay erişim ve işleme sağlamak için. Aşağıdaki örnek, beyzbol atıcılarının adlarını, attıkları atış sayısını ve kazanılan çalıştırma sayısını (alan hatası olmadan puanlanan çalıştırmalar) ve vazgeçtikleri isabetleri içeren bir nesne dizisini Tuple<T1,T2,T3,T4> tanımlar. Dizi, her sürahinin ComputeStatistics kazanılan çalıştırma ortalamasını (dokuz vuruşlu bir oyunda verilen ortalama çalıştırma sayısı) ve her inning için verilen ortalama isabet sayısını hesaplayan yöntemine geçirilir. yöntemi, varsayımsal bir etkinlik ortalamasını hesaplamak için de bu iki ortalamayı kullanır.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Tuple<string, decimal, int, int>[] pitchers  =  
           { Tuple.Create("McHale, Joe", 240.1m, 221, 96),
             Tuple.Create("Paul, Dave", 233.1m, 231, 84), 
             Tuple.Create("Williams, Mike", 193.2m, 183, 86),
             Tuple.Create("Blair, Jack", 168.1m, 146, 65), 
             Tuple.Create("Henry, Walt", 140.1m, 96, 30),
             Tuple.Create("Lee, Adam", 137.2m, 109, 45),
             Tuple.Create("Rohr, Don", 101.0m, 110, 42) };
      Tuple<string, double, double, double>[] results= ComputeStatistics(pitchers);

      // Display the results.
      Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}\n", 
                        "Pitcher", "ERA", "Hits/Inn.", "Effectiveness");
      foreach (var result in results)
         Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                        result.Item1, result.Item2, result.Item3, result.Item4);
   }

   private static Tuple<string, double, double, double>[] ComputeStatistics(Tuple<string, decimal, int, int>[] pitchers)
   {    
      var list = new List<Tuple<string, double, double, double>>();
      Tuple<string, double, double, double> result;

      foreach (var pitcher in pitchers)
      {
         // Decimal portion of innings pitched represents 1/3 of an inning
         double innings = (double) Math.Truncate(pitcher.Item2);
         innings = innings + (((double)pitcher.Item2 - innings) * .33);
         
         double ERA = pitcher.Item4/innings * 9;
         double hitsPerInning = pitcher.Item3/innings;
         double EI = (ERA * 2 + hitsPerInning * 9)/3;
         result = new Tuple<string, double, double, double>
                           (pitcher.Item1, ERA, hitsPerInning, EI);
         list.Add(result);
      }
      return list.ToArray();
   }
}
// The example displays the following output;
//       Pitcher                    ERA   Hits/Inn.   Effectiveness
//       
//       McHale, Joe               3.60        0.92            5.16
//       Paul, Dave                3.24        0.99            5.14
//       Williams, Mike            4.01        0.95            5.52
//       Blair, Jack               3.48        0.87            4.93
//       Henry, Walt               1.93        0.69            3.34
//       Lee, Adam                 2.95        0.80            4.36
//       Rohr, Don                 3.74        1.09            5.76

open System

let computeStatistics (pitchers: Tuple<string, decimal, int, int>[]) =
    [| for pitcher in pitchers do
        // Decimal portion of innings pitched represents 1/3 of an inning
        let innings =  truncate (double pitcher.Item2) |> double
        let innings = innings + (double pitcher.Item2 - innings) * 0.33
        
        let ERA = double pitcher.Item4 / innings * 9.
        let hitsPerInning = double pitcher.Item3 / innings
        let EI = (ERA * 2. + hitsPerInning * 9.) / 3.
        Tuple<string, double, double, double>(pitcher.Item1, ERA, hitsPerInning, EI)|]

let pitchers  =  
    [| Tuple.Create("McHale, Joe", 240.1m, 221, 96)
       Tuple.Create("Paul, Dave", 233.1m, 231, 84)
       Tuple.Create("Williams, Mike", 193.2m, 183, 86)
       Tuple.Create("Blair, Jack", 168.1m, 146, 65) 
       Tuple.Create("Henry, Walt", 140.1m, 96, 30)
       Tuple.Create("Lee, Adam", 137.2m, 109, 45)
       Tuple.Create("Rohr, Don", 101.0m, 110, 42) |]

let results = computeStatistics pitchers

// Display the results.
printfn "%-20s %9s %11s %15s\n" "Pitcher" "ERA" "Hits/Inn." "Effectiveness"
for result in results do
    printfn $"{result.Item1,-20} {result.Item2,9:F2} {result.Item3,11:F2} {result.Item4,15:F2}"

// The example displays the following output
//       Pitcher                    ERA   Hits/Inn.   Effectiveness
//       
//       McHale, Joe               3.60        0.92            5.16
//       Paul, Dave                3.24        0.99            5.14
//       Williams, Mike            4.01        0.95            5.52
//       Blair, Jack               3.48        0.87            4.93
//       Henry, Walt               1.93        0.69            3.34
//       Lee, Adam                 2.95        0.80            4.36
//       Rohr, Don                 3.74        1.09            5.76

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim pitchers() =  
               { Tuple.Create("McHale, Joe", 240.1d, 221, 96),
                 Tuple.Create("Paul, Dave", 233.1d, 231, 84), 
                 Tuple.Create("Williams, Mike", 193.2d, 183, 86),
                 Tuple.Create("Blair, Jack", 168.1d, 146, 65), 
                 Tuple.Create("Henry, Walt", 140.1d, 96, 30),
                 Tuple.Create("Lee, Adam", 137.2d, 109, 45),
                 Tuple.Create("Rohr, Don", 101.0d, 110, 42) }
      Dim results() = ComputeStatistics(pitchers)

      ' Display the results.
      Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}", "Pitcher", "ERA", "Hits/Inn.", "Effectiveness")
      Console.WriteLine()
      For Each result In results
         Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                        result.Item1, result.Item2, result.Item3, result.Item4)
      Next
   End Sub
   
   Private Function ComputeStatistics(pitchers() As Tuple(Of String, Decimal, Integer, Integer)) _ 
                                As Tuple(Of String, Double, Double, Double)()
      Dim list As New List(Of Tuple(Of String, Double, Double, Double))
      Dim result As Tuple(Of String, Double, Double, Double)

      For Each pitcher As Tuple(Of String, Decimal, Integer, Integer) In pitchers
         ' Decimal portion of innings pitched represents 1/3 of an inning
         Dim innings As Double = CDbl(Math.Truncate(pitcher.Item2))
         innings = innings + ((pitcher.Item2 - innings) * .33)
         
         Dim ERA As Double = pitcher.Item4/innings * 9
         Dim hitsPerInning As Double = pitcher.Item3/innings
         Dim EI As Double = (ERA * 2 + hitsPerInning * 9)/3
         result = New Tuple(Of String, Double, Double, Double) _
                           (pitcher.Item1, ERA, hitsPerInning, EI)
         list.Add(result) 
      Next
      Return list.ToArray()
   End Function
End Module
' The example displays the following output:
'       Pitcher                    ERA   Hits/Inn.   Effectiveness
'       
'       McHale, Joe               3.60        0.92            5.16
'       Paul, Dave                3.24        0.99            5.14
'       Williams, Mike            4.01        0.95            5.52
'       Blair, Jack               3.48        0.87            4.93
'       Henry, Walt               1.93        0.69            3.34
'       Lee, Adam                 2.95        0.80            4.36
'       Rohr, Don                 3.74        1.09            5.76

Parametre (C# dilinde) veya out parametre kullanmadan ByRef bir yöntemden birden çok değer döndürmek için (Visual Basic'te). Örneğin, önceki örnek bir nesne dizisinde Tuple<T1,T2,T3,T4> , atıcının adıyla birlikte hesaplanan istatistiklerini döndürür.
Tek bir parametre aracılığıyla bir yönteme birden çok değer geçirmek için. Örneğin, yöntemi, iş parçacığının Thread.Start(Object) başlangıçta yürüttüğü yönteme tek bir değer sağlamanıza olanak tanıyan tek bir parametreye sahiptir. Yöntem bağımsız değişkeni olarak bir Tuple<T1,T2,T3,T4> nesne sağlarsanız, iş parçacığının başlangıç yordamını dört veri öğesiyle sağlayabilirsiniz.

Oluşturucular

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

Özellikler

Name	Description
Item1	Geçerli Tuple<T1,T2,T3,T4> nesnenin ilk bileşeninin değerini alır.
Item2	Geçerli Tuple<T1,T2,T3,T4> nesnenin ikinci bileşeninin değerini alır.
Item3	Geçerli Tuple<T1,T2,T3,T4> nesnenin üçüncü bileşeninin değerini alır.
Item4	Geçerli Tuple<T1,T2,T3,T4> nesnenin dördüncü bileşeninin değerini alır.

Yöntemler

Name	Description
Equals(Object)	Geçerli Tuple<T1,T2,T3,T4> 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> nesnenin karma kodunu döndürür.
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Bu Tuple<T1,T2,T3,T4> örneğin değerini temsil eden bir dize döndürür.

Belirtik Arabirim Kullanımları

Name	Description
IComparable.CompareTo(Object)	Geçerli Tuple<T1,T2,T3,T4> nesneyi belirtilen 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 gösteren 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> nesneyi belirtilen bir nesneyle karşılaştırır ve geçerli nesnenin sıralama düzeninde belirtilen nesneyle aynı konumda mı, sonra mı olduğunu belirten bir tamsayı döndürür.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Geçerli Tuple<T1,T2,T3,T4> 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> 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ı

Name	Description
Deconstruct<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>, T1, T2, T3, T4)	4 öğeli bir demeti ayrı değişkenler halinde yok eder.
ToValueTuple<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>)	Sınıfının bir örneğini `Tuple` yapı örneğine `ValueTuple` dönüştürür.

Şunlara uygulanır

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?