Sdílet prostřednictvím


Tuple<T1,T2> Třída

Definice

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

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

Viz také