Tuple<T1,T2> 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.

2 tanımlama grubu veya çifti temsil eder.

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

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

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

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

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

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

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

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

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

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

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

Devralma: Object
Tuple<T1,T2>

Ö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> sınıfı, iki bileşeni olan bir tanımlama grubu olan 2 tanımlama grubu veya çifti temsil eder. 2 tanımlama grubu bir KeyValuePair<TKey,TValue> yapıya benzer.

Oluşturucuyu veya statik Tuple<T1,T2> yöntemi çağırarak Tuple<T1,T2> bir Tuple.Create<T1,T2>(T1, T2) nesne örneği oluşturabilirsiniz. Salt okunur Item1 ve Item2 örnek özelliklerini kullanarak tanımlama grubu bileşenlerinin değerlerini 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 veritabanındaki bir kaydı temsil edebilir ve bileşenleri bu kaydın alanlarını temsil edebilir.

Bir veri kümesine kolay erişim ve işleme sağlamak için. Aşağıdaki örnek, öğrencilerin adlarını ve bunlara karşılık gelen test puanlarını içeren bir nesne dizisini Tuple<T1,T2> tanımlar. Ardından ortalama test puanını hesaplamak için diziyi yineler.

using System;

public class Example
{
   public static void Main()
   {
      Tuple<string, Nullable<int>>[] scores = 
                    { new Tuple<string, Nullable<int>>("Jack", 78),
                      new Tuple<string, Nullable<int>>("Abbey", 92), 
                      new Tuple<string, Nullable<int>>("Dave", 88),
                      new Tuple<string, Nullable<int>>("Sam", 91), 
                      new Tuple<string, Nullable<int>>("Ed", null),
                      new Tuple<string, Nullable<int>>("Penelope", 82),
                      new Tuple<string, Nullable<int>>("Linda", 99),
                      new Tuple<string, Nullable<int>>("Judith", 84) };
      int number;
      double mean = ComputeMean(scores, out number);
      Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number);
   }

   private static double ComputeMean(Tuple<string, Nullable<int>>[] scores, out int n) 
   {
      n = 0;      
      int sum = 0;
      foreach (var score in scores)
      {
         if (score.Item2.HasValue)
         { 
            n += 1;
            sum += score.Item2.Value;
         }
      }     
      if (n > 0)
         return sum / (double) n;
      else
         return 0;
   }
}
// The example displays the following output:
//       Average test score: 87.71 (n=7)

open System

let scores = 
    [| Tuple<string, Nullable<int>>("Jack", 78)
       Tuple<string, Nullable<int>>("Abbey", 92) 
       Tuple<string, Nullable<int>>("Dave", 88)
       Tuple<string, Nullable<int>>("Sam", 91) 
       Tuple<string, Nullable<int>>("Ed", Nullable())
       Tuple<string, Nullable<int>>("Penelope", 82)
       Tuple<string, Nullable<int>>("Linda", 99)
       Tuple<string, Nullable<int>>("Judith", 84) |]

let computeMean (scores: Tuple<string, Nullable<int>>[]) (n: int outref) = 
    n <- 0      
    let mutable sum = 0
    for _, score in scores do
        if score.HasValue then
            n <- n + 1
            sum <- sum + score.Value
    if n > 0 then
        double sum / double n
    else
        0

let mutable number = 0
let mean = computeMean scores &number
printfn $"Average test score: {mean:N2} (n={number})"
// The example displays the following output:
//       Average test score: 87.71 (n=7)

Module Example
   Public Sub Main()
      Dim scores() As Tuple(Of String, Nullable(Of Integer)) = 
                      { New Tuple(Of String, Nullable(Of Integer))("Jack", 78),
                        New Tuple(Of String, Nullable(Of Integer))("Abbey", 92), 
                        New Tuple(Of String, Nullable(Of Integer))("Dave", 88),
                        New Tuple(Of String, Nullable(Of Integer))("Sam", 91), 
                        New Tuple(Of String, Nullable(Of Integer))("Ed", Nothing),
                        New Tuple(Of String, Nullable(Of Integer))("Penelope", 82),
                        New Tuple(Of String, Nullable(Of Integer))("Linda", 99),
                        New Tuple(Of String, Nullable(Of Integer))("Judith", 84) }
      Dim number As Integer
      Dim mean As Double = ComputeMean(scores, number)
      Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number)
   End Sub
   
   Private Function ComputeMean(scores() As Tuple(Of String, Nullable(Of Integer)), 
                                ByRef n As Integer) As Double
      n = 0      
      Dim sum As Integer
      For Each score In scores
         If score.Item2.HasValue Then 
            n += 1
            sum += score.Item2.Value
         End If
      Next     
      If n > 0 Then
         Return sum / n
      Else
         Return 0
      End If             
   End Function
End Module
' The example displays the following output:
'       Average test score: 87.71 (n=7)

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 aşağıdaki örnekte, tamsayı bölmeden kaynaklanan bölümü ve kalan bölümü döndürmek için bir Tuple<T1,T2> nesne kullanılır.

using System;

public class Class1
{
   public static void Main()
   {
      int dividend, divisor;
      Tuple<int, int> result;
      
      dividend = 136945; divisor = 178;
      result = IntegerDivide(dividend, divisor);
      if (result != null)
         Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                           dividend, divisor, result.Item1, result.Item2);
      else
         Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
                        
      dividend = Int32.MaxValue; divisor = -2073;
      result = IntegerDivide(dividend, divisor);
      if (result != null)
         Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                           dividend, divisor, result.Item1, result.Item2);
      else
         Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
   }

   private static Tuple<int, int> IntegerDivide(int dividend, int divisor)
   {
      try {
         int remainder;
         int quotient = Math.DivRem(dividend, divisor, out remainder);
         return new Tuple<int, int>(quotient, remainder);
      }   
      catch (DivideByZeroException) {
         return null;
      }      
   }
}
// The example displays the following output:
//       136945 \ 178 = 769, remainder 63
//       2147483647 \ -2073 = -1035930, remainder 757

open System

let integerDivide (dividend: int) divisor =
    try
        let quotient, remainder = Math.DivRem(dividend, divisor)
        Tuple<int, int>(quotient, remainder)
    with :? DivideByZeroException ->
        Unchecked.defaultof<Tuple<int, int>>

[<EntryPoint>]
let main _ =
    let dividend = 136945 
    let divisor = 178
    let result = integerDivide dividend divisor
    if box result <> null then
        printfn $@"{dividend} \ {divisor} = {result.Item1}, remainder {result.Item2}" 
    else
        printfn $@"{dividend} \ {divisor} = <Error>"
                    
    let dividend = Int32.MaxValue 
    let divisor = -2073
    let result = integerDivide dividend divisor
    if box result <> null then
        printfn $@"{dividend} \ {divisor} = {result.Item1}, remainder {result.Item2}" 
    else
        printfn $@"{dividend} \ {divisor} = <Error>"
    0
// The example displays the following output:
//       136945 \ 178 = 769, remainder 63
//       2147483647 \ -2073 = -1035930, remainder 757

Module modMain
   Public Sub Main()
      Dim dividend, divisor As Integer
      Dim result As Tuple(Of Integer, Integer)
      
      dividend = 136945 : divisor = 178
      result = IntegerDivide(dividend, divisor)
      If result IsNot Nothing Then
         Console.WriteLine("{0} \ {1} = {2}, remainder {3}", 
                           dividend, divisor, result.Item1, result.Item2)
      Else
         Console.WriteLine("{0} \ {1} = <Error>", dividend, divisor)
      End If
                        
      dividend = Int32.MaxValue : divisor = -2073
      result = IntegerDivide(dividend, divisor)
      If result IsNot Nothing Then
         Console.WriteLine("{0} \ {1} = {2}, remainder {3}", 
                           dividend, divisor, result.Item1, result.Item2)
      Else
         Console.WriteLine("{0} \ {1} = <Error>", dividend, divisor)
      End If
   End Sub
   
   Private Function IntegerDivide(dividend As Integer, divisor As Integer) As Tuple(Of Integer, Integer)
      Try
         Dim remainder As Integer
         Dim quotient As Integer = Math.DivRem(dividend, divisor, remainder)
         Return New Tuple(Of Integer, Integer)(quotient, remainder)
      Catch e As DivideByZeroException
         Return Nothing
      End Try      
   End Function
End Module
' The example displays the following output:
'       136945 \ 178 = 769, remainder 63
'       2147483647 \ -2073 = -1035930, remainder 757

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> nesne sağlarsanız, iş parçacığının başlangıç yordamını iki veri öğesiyle sağlayabilirsiniz.

Oluşturucular

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

Özellikler

Name	Description
Item1	Geçerli Tuple<T1,T2> nesnenin ilk bileşeninin değerini alır.
Item2	Geçerli Tuple<T1,T2> nesnenin ikinci bileşeninin değerini alır.

Yöntemler

Name	Description
Equals(Object)	Geçerli Tuple<T1,T2> nesnenin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
GetHashCode()	Geçerli Tuple<T1,T2> 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> ö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> 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)	Geçerli Tuple<T1,T2> nesneyi belirtilen bir karşılaştırıcı kullanarak 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 gösteren bir tamsayı döndürür.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Geçerli Tuple<T1,T2> 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> 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>(Tuple<T1,T2>, T1, T2)	2 öğeli bir demeti ayrı değişkenler halinde yok eder.
ToValueTuple<T1,T2>(Tuple<T1,T2>)	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?