Tuple<T1,T2> Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Představuje 2 řazenou kolekci členů nebo dvojici.

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

Parametry typu

T1

Typ první součásti řazené kolekce členů.

T2

Typ druhé součásti řazené kolekce členů.

Dědičnost: Object
Tuple<T1,T2>

Atributy: SerializableAttribute

Implementuje: IStructuralComparable IStructuralEquatable IComparable ITuple

Poznámky

Řazená kolekce členů je datová struktura, která obsahuje určitý počet a pořadí hodnot. Třída Tuple<T1,T2> představuje 2 řazenou kolekci členů nebo dvojici, což je řazená kolekce členů, která má dvě komponenty. Řazená kolekce členů je podobná KeyValuePair<TKey,TValue> struktuře.

Objekt můžete vytvořit vytvořením instance Tuple<T1,T2> voláním Tuple<T1,T2> konstruktoru nebo statické Tuple.Create<T1,T2>(T1, T2) metody. Hodnoty komponent řazené kolekce členů můžete načíst pomocí vlastností jen Item1 pro čtení a Item2 instance.

Řazené kolekce členů se obvykle používají čtyřmi různými způsoby:

K reprezentaci jediné datové sady. Kolekce členů může například představovat záznam v databázi a její součásti můžou představovat pole daného záznamu.

K zajištění snadného přístupu k datové sadě a manipulace s datovou sadou. Následující příklad definuje pole Tuple<T1,T2> objektů, které obsahují jména studentů a odpovídající skóre testů. Pak iteruje pole k výpočtu průměrného skóre testu.

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)

Chcete-li vrátit více hodnot z metody bez použití out parametrů (v jazyce C#) nebo ByRef parametrů (v Visual Basic). Následující příklad například používá Tuple<T1,T2> objekt k vrácení podílu a zbytku, který je výsledkem dělení celého čísla.

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

Pro předání více hodnot metodě prostřednictvím jediného parametru. Například metoda má jeden parametr, Thread.Start(Object) který umožňuje zadat jednu hodnotu metodě, kterou vlákno spouští při spuštění. Pokud jako argument metody zadáte Tuple<T1,T2> objekt, můžete zadat rutinu spuštění vlákna se dvěma položkami dat.

Konstruktory

Tuple<T1,T2>(T1, T2)

Inicializuje novou instanci Tuple<T1,T2> třídy.

Vlastnosti

Item1	Získá hodnotu první komponenty aktuálního Tuple<T1,T2> objektu.
Item2	Získá hodnotu druhé komponenty aktuálního Tuple<T1,T2> objektu.

Metody

Equals(Object)	Vrátí hodnotu, která označuje, zda je aktuální Tuple<T1,T2> objekt roven zadanému objektu.
GetHashCode()	Vrátí kód hash pro aktuální Tuple<T1,T2> objekt.
GetType()	Type Získá aktuální instanci. (Zděděno od Object)
MemberwiseClone()	Vytvoří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
ToString()	Vrátí řetězec, který představuje hodnotu této Tuple<T1,T2> instance.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)	Porovná aktuální Tuple<T1,T2> objekt se zadaným objektem a vrátí celé číslo, které označuje, zda je aktuální objekt před, za nebo ve stejné pozici jako zadaný objekt v pořadí řazení.
IStructuralComparable.CompareTo(Object, IComparer)	Porovná aktuální Tuple<T1,T2> objekt se zadaným objektem pomocí zadaného porovnávače a vrátí celé číslo, které označuje, zda je aktuální objekt před, za nebo ve stejné pozici jako zadaný objekt v pořadí řazení.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Vrátí hodnotu, která určuje, zda je aktuální Tuple<T1,T2> objekt roven zadanému objektu na základě zadané metody porovnání.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Vypočítá kód hash pro aktuální Tuple<T1,T2> objekt pomocí zadané výpočetní metody.
ITuple.Item[Int32]	Získá hodnotu zadaného `Tuple` prvku.
ITuple.Length	Získá počet prvků v sadě `Tuple`.

Metody rozšíření

Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)	Dekonstruuje řazenou kolekci členů se 2 prvky do samostatných proměnných.
ToValueTuple<T1,T2>(Tuple<T1,T2>)	Převede instanci `Tuple` třídy na instanci `ValueTuple` struktury.

Platí pro

Sdílet prostřednictvím