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

Başvuru

Tanım

Ad Alanı:: System

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

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

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

Ö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.

6 tanımlama grubu veya cinsiyet tanımlama grubu temsil eder.

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

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

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

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

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

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

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

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

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

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

Public Class Tuple(Of T1, T2, T3, T4, T5, T6)
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ü.

T6

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

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

Öznitelikler: SerializableAttribute

Uygulamalar: IStructuralComparable IStructuralEquatable IComparable ITuple

Açıklamalar

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

veya statik Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) yöntemini çağırarak Tuple<T1,T2,T3,T4,T5,T6> bir Tuple<T1,T2,T3,T4,T5,T6> nesne örneği oluşturabilirsiniz. Salt okunur Item1, , , Item2 Item4 Item3, Item5ve Item6 ö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, 1960 ile 2000 arasında yapılan her sayım için New York City için nüfus verilerini içeren bir Tuple<T1,T2,T3,T4,T5,T6> nesneyi tanımlar. Sextuple, sayımlar arasındaki yıllık değişiklik oranını ve 50 yıllık dönemin tamamı için yıllık değişiklik oranını hesaplayan yöntemine geçirilir ComputePopulationChange .

using System;

public class Example
{
   public static void Main()
   {
      // Get population data for New York City, 1960-2000.
      var population = 
           Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278);
      var rate = ComputePopulationChange(population);
      // Display results.
      Console.WriteLine("Population Change, {0}, 1960-2000\n", population.Item1);
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
      Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA");
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
      Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50);
   }

   private static Tuple<string, double, double, double, double, double> ComputePopulationChange(
           Tuple<string, int, int, int, int, int> data)  
   {           
      var rate = Tuple.Create(data.Item1, 
                              (double)(data.Item3 - data.Item2)/data.Item2, 
                              (double)(data.Item4 - data.Item3)/data.Item3, 
                              (double)(data.Item5 - data.Item4)/data.Item4, 
                              (double)(data.Item6 - data.Item5)/data.Item5,
                              (double)(data.Item6 - data.Item2)/data.Item2 );
      return rate;
   }           
}
// The example displays the following output:
//       Population Change, New York, 1960-2000
//       
//       Year      Population Annual Rate
//       1960       7,781,984          NA
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1960-2000                 0.06 %

open System

let computePopulationChange (data: Tuple<string, int, int, int, int, int>) =  
    Tuple.Create(data.Item1, 
                 double ((data.Item3 - data.Item2) / data.Item2), 
                 double ((data.Item4 - data.Item3) / data.Item3), 
                 double ((data.Item5 - data.Item4) / data.Item4), 
                 double ((data.Item6 - data.Item5) / data.Item5),
                 double ((data.Item6 - data.Item2) / data.Item2))

// Get population data for New York City, 1960-2000.
let population = 
      Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278)
let rate = computePopulationChange population
// Display results.
printfn $"Population Change, {population.Item1}, 1960-2000\n"
printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
printfn $"""1960      {population.Item2,10:N0} {"NA",11}"""
printfn $"1970      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
printfn $"1980      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}"
printfn $"1990      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}"
printfn $"2000      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}"
printfn $"""1960-2000 {"",10:N0} {rate.Item6 / 50.,11:P2}"""

// The example displays the following output:
//       Population Change, New York, 1960-2000
//       
//       Year      Population Annual Rate
//       1960       7,781,984          NA
//       1970       7,894,862      0.15 %
//       1980       7,071,639     -1.04 %
//       1990       7,322,564      0.35 %
//       2000       8,008,278      0.94 %
//       1960-2000                 0.06 %

Module Example
   Public Sub Main()
      ' Get population data for New York City, 1960-2000.
      Dim population = Tuple.Create(
                     "New York", 7781984, 7894862, 7071639, 7322564, 8008278)
      Dim rate = ComputePopulationChange(population)      
      ' Display results.
      Console.WriteLine("Population Change, {0}, 1960-2000", population.Item1)
      Console.WriteLine()
      Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
      Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA")
      Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
      Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
      Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
      Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
      Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50)
   End Sub
   
      ' Compute rate of population change by decade and overall.
   Private Function ComputePopulationChange(data As Tuple(Of String, Integer, Integer, Integer, Integer, Integer)) _ 
           As Tuple(Of String, Double, Double, Double, Double, Double)
      Dim rate = Tuple.Create(data.Item1, 
                              (data.Item3 - data.Item2)/data.Item2, 
                              (data.Item4 - data.Item3)/data.Item3, 
                              (data.Item5 - data.Item4)/data.Item4, 
                              (data.Item6 - data.Item5)/data.Item5,
                              (data.Item6 - data.Item2)/data.Item2 )
      Return rate
   End Function           
End Module
' The example displays the following output:
'       Population Change, New York, 1960-2000
'       
'       Year      Population Annual Rate
'       1960       7,781,984          NA
'       1970       7,894,862      0.15 %
'       1980       7,071,639     -1.04 %
'       1990       7,322,564      0.35 %
'       2000       8,008,278      0.94 %
'       1960-2000                 0.06 %

Parametre (C# dilinde) veya ByRef parametre (Visual Basic) kullanmadan out bir yöntemden birden çok değer döndürmek için. Örneğin, önceki örnek bir nesnede Tuple<T1,T2,T3,T4,T5,T6> şehir 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önteminde, 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 parametre vardır. Yöntem bağımsız değişkeni olarak bir Tuple<T1,T2,T3,T4,T5,T6> nesne sağlarsanız, iş parçacığının başlangıç yordamını altı veri öğesiyle sağlayabilirsiniz.

Oluşturucular

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

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

Özellikler

Item1	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin ilk bileşeninin değerini alır.
Item2	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin ikinci bileşeninin değerini alır.
Item3	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin üçüncü bileşeninin değerini alır.
Item4	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin dördüncü bileşeninin değerini alır.
Item5	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin beşinci bileşeninin değerini alır.
Item6	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin altıncı bileşeninin değerini alır.

Yöntemler

Equals(Object)	Geçerli Tuple<T1,T2,T3,T4,T5,T6> nesnenin belirtilen nesneye eşit olup olmadığını gösteren bir değer döndürür.
GetHashCode()	Geçerli Tuple<T1,T2,T3,T4,T5,T6> 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,T6> ö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,T6> 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,T6> 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.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Geçerli Tuple<T1,T2,T3,T4,T5,T6> 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,T6> 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,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	6 öğeli bir tanımlama kümesini ayrı değişkenlere ayırır.
ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)	sınıfının bir örneğini `Tuple` yapı örneğine `ValueTuple` dönüştürür.

Şunlara uygulanır