Tuple<T1,T2> Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

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

Atrybuty: SerializableAttribute

Implementuje: IStructuralComparable IStructuralEquatable IComparable ITuple

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

Udostępnij za pośrednictwem