Udostępnij za pośrednictwem


Tuple<T1,T2> Klasa

Definicja

Reprezentuje krotkę 2-krotkową lub parę.

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 pierwszego składnika spójnej kolekcji.

T2

Typ drugiego składnika spójnej kolekcji.

Dziedziczenie
Tuple<T1,T2>
Atrybuty
Implementuje

Uwagi

Spójna kolekcja to struktura danych, która ma określoną liczbę i kolejność wartości. Klasa Tuple<T1,T2> reprezentuje krotkę 2-krotkową lub parę, która jest krotką zawierającą dwa składniki. Krotka 2 jest podobna KeyValuePair<TKey,TValue> do struktury.

Wystąpienie obiektu można utworzyć Tuple<T1,T2> , wywołując Tuple<T1,T2> konstruktor lub metodę statyczną Tuple.Create<T1,T2>(T1, T2) . Wartości składników krotki można pobrać przy użyciu właściwości tylko do Item1 odczytu i Item2 wystąpienia.

Spójne kolekcje są powszechnie wykorzystywane na cztery różne sposoby:

  • Reprezentowanie jednego zestawu danych. Na przykład krotka może reprezentować rekord w bazie danych, a jego składniki mogą reprezentować pola tego rekordu.

  • Zapewnienie łatwego dostępu do zestawu danych i możliwości wykonywania w nim różnych operacji. W poniższym przykładzie zdefiniowano tablicę Tuple<T1,T2> obiektów zawierających nazwy uczniów i odpowiadające im wyniki testu. Następnie iteruje tablicę, aby obliczyć średni wynik 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)
    
  • Aby zwrócić wiele wartości z metody bez użycia parametrów out (w języku C#) lub ByRef parametrów (w Visual Basic). Na przykład w poniższym przykładzie użyto Tuple<T1,T2> obiektu, aby zwrócić iloraz i resztę wynikową z dzielenia liczb całkowitych.

    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
    
  • Przekazywanie wielu wartości do metody za pomocą jednego parametru. Na przykład Thread.Start(Object) metoda ma jeden parametr, który umożliwia podanie jednej wartości do metody wykonywanej przez wątek podczas uruchamiania. Jeśli podasz obiekt jako argument metody, możesz podać procedurę Tuple<T1,T2> uruchamiania wątku z dwoma elementami danych.

Konstruktory

Tuple<T1,T2>(T1, T2)

Inicjuje nowe wystąpienie klasy Tuple<T1,T2>.

Właściwości

Item1

Pobiera wartość pierwszego składnika bieżącego Tuple<T1,T2> obiektu.

Item2

Pobiera wartość drugiego składnika bieżącego Tuple<T1,T2> obiektu.

Metody

Equals(Object)

Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2> obiekt jest równy określonemu obiektowi.

GetHashCode()

Zwraca kod skrótu dla bieżącego Tuple<T1,T2> obiektu.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący wartość tego Tuple<T1,T2> wystąpienia.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje bieżący Tuple<T1,T2> obiekt z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy bieżący obiekt znajduje się przed, po, czy w tej samej pozycji co określony obiekt w kolejności sortowania.

IStructuralComparable.CompareTo(Object, IComparer)

Porównuje bieżący Tuple<T1,T2> obiekt z określonym obiektem przy użyciu określonego porównania i zwraca liczbę całkowitą wskazującą, czy bieżący obiekt znajduje się przed, po, czy w tej samej pozycji co określony obiekt w kolejności sortowania.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2> obiekt jest równy określonemu obiektowi na podstawie określonej metody porównania.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Oblicza kod skrótu dla bieżącego Tuple<T1,T2> obiektu przy użyciu określonej metody obliczeniowej.

ITuple.Item[Int32]

Pobiera wartość określonego Tuple elementu.

ITuple.Length

Pobiera liczbę elementów w elemecie Tuple.

Metody rozszerzania

Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)

Dekonstruktoruje krotkę z 2 elementami na oddzielne zmienne.

ToValueTuple<T1,T2>(Tuple<T1,T2>)

Konwertuje wystąpienie Tuple klasy na wystąpienie ValueTuple struktury.

Dotyczy

Zobacz też