Tuple<T1,T2,T3> 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ę 3-krotkową lub potrójną.

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

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

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

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

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

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

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

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

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

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

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

Parametry typu

T1

Typ pierwszego składnika spójnej kolekcji.

T2

Typ drugiego składnika spójnej kolekcji.

T3

Typ trzeciego składnika spójnej kolekcji.

Dziedziczenie: Object
Tuple<T1,T2,T3>

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,T3> reprezentuje krotkę 3-krotkową lub potrójną, która jest krotką zawierającą trzy składniki.

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

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

Reprezentowanie jednego zestawu danych. Na przykład spójna kolekcja może reprezentować rekord bazy danych, a jej składniki mogą reprezentować poszczególne pola 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,T3> obiektów, które zawierają nazwy uczniów, ich średnie wyniki testów i liczbę wykonanych testów. Tablica jest przekazywana do ComputeStatistics metody , która oblicza średnią i odchylenie standardowe wyników testu.

using System;

public class Example
{
   public static void Main()
   {
      Tuple<string, double, int>[] scores = 
                    { Tuple.Create("Jack", 78.8, 8),
                      Tuple.Create("Abbey", 92.1, 9), 
                      Tuple.Create("Dave", 88.3, 9),
                      Tuple.Create("Sam", 91.7, 8), 
                      Tuple.Create("Ed", 71.2, 5),
                      Tuple.Create("Penelope", 82.9, 8),
                      Tuple.Create("Linda", 99.0, 9),
                      Tuple.Create("Judith", 84.3, 9) };
      var result = ComputeStatistics(scores);
      Console.WriteLine("Mean score: {0:N2} (SD={1:N2}) (n={2})", 
                        result.Item2, result.Item3, result.Item1);
   }

   private static Tuple<int, double, double> ComputeStatistics(Tuple<string, double, int>[] scores) 
   {
      int n = 0;
      double sum = 0;

      // Compute the mean.
      foreach (var score in scores)
      {
         n += score.Item3;
         sum += score.Item2 * score.Item3;
      }
      double mean = sum / n;
      
      // Compute the standard deviation.
      double ss = 0;
      foreach (var score in scores)
      {
         ss = Math.Pow(score.Item2 - mean, 2);
      }
      double sd = Math.Sqrt(ss/scores.Length);
      return Tuple.Create(scores.Length, mean, sd);
   }
}
// The example displays the following output:
//       Mean score: 87.02 (SD=0.96) (n=8)

open System

let computeStatistics (scores: Tuple<string, double, int>[]) = 
    let mutable n = 0
    let mutable sum = 0.

    // Compute the mean.
    for score in scores do
        n <- n + score.Item3
        sum <- sum + score.Item2 * double score.Item3
    let mean = sum / double n
    
    // Compute the standard deviation.
    let mutable ss = 0.
    for score in scores do
        ss <- (score.Item2 - mean) ** 2.
    let sd = sqrt (ss / double scores.Length)
    Tuple.Create(scores.Length, mean, sd)

let scores = 
    [| Tuple.Create("Jack", 78.8, 8)
       Tuple.Create("Abbey", 92.1, 9) 
       Tuple.Create("Dave", 88.3, 9)
       Tuple.Create("Sam", 91.7, 8) 
       Tuple.Create("Ed", 71.2, 5)
       Tuple.Create("Penelope", 82.9, 8)
       Tuple.Create("Linda", 99.0, 9)
       Tuple.Create("Judith", 84.3, 9) |]
let result = computeStatistics scores
printfn $"Mean score: {result.Item2:N2} (SD={result.Item3:N2}) (n={result.Item1})"
// The example displays the following output:
//       Mean score: 87.02 (SD=0.96) (n=8)

Module Example
   Public Sub Main()
      Dim scores() = 
                      { Tuple.Create("Jack", 78.8, 8),
                        Tuple.Create("Abbey", 92.1, 9), 
                        Tuple.Create("Dave", 88.3, 9),
                        Tuple.Create("Sam", 91.7, 8), 
                        Tuple.Create("Ed", 71.2, 5),
                        Tuple.Create("Penelope", 82.9, 8),
                        Tuple.Create("Linda", 99.0, 9),
                        Tuple.Create("Judith", 84.3, 9) }
      Dim result = ComputeStatistics(scores)
      Console.WriteLine("Mean score: {0:N2} (SD={1:N2}) (n={2})", 
                        result.Item2, result.Item3, result.Item1)
   End Sub
   
   Private Function ComputeStatistics(scores() As Tuple(Of String, Double, Integer)) _ 
                                As Tuple(Of Integer, Double, Double)
      Dim n As Integer = 0      
      Dim sum As Double = 0
      
      ' Compute the mean.
      For Each score In scores
         n+= score.Item3 
         sum += score.Item2 * score.Item3
      Next     
      Dim mean As Double = sum / n

      ' Compute the standard deviation.
      Dim ss As Double = 0
      For Each score In scores
         ss = Math.Pow(score.Item2 - mean, 2)
      Next
      Dim sd As Double = Math.Sqrt(ss/scores.Length)
      Return Tuple.Create(scores.Length, mean, sd)
   End Function
End Module
' The example displays the following output:
'       Mean score: 87.02 (SD=0.96) (n=8)

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 poprzedni przykład zwraca statystyki wyników testu podsumowania w Tuple<T1,T2,T3> obiekcie.
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,T3> uruchamiania wątku z trzema elementami danych.

Konstruktory

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

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

Właściwości

Item1	Pobiera wartość pierwszego składnika bieżącego Tuple<T1,T2,T3> obiektu.
Item2	Pobiera wartość drugiego składnika bieżącego Tuple<T1,T2,T3> obiektu.
Item3	Pobiera wartość trzeciego składnika bieżącego Tuple<T1,T2,T3> obiektu.

Metody

Equals(Object)	Zwraca wartość wskazującą, czy bieżący Tuple<T1,T2,T3> obiekt jest równy określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla bieżącego Tuple<T1,T2,T3> 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,T3> wystąpienia.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)	Porównuje bieżący Tuple<T1,T2,T3> 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,T3> 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,T3> 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,T3> 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,T3>(Tuple<T1,T2,T3>, T1, T2, T3)	Dekonstruktoruje krotkę z 3 elementami na oddzielne zmienne.
ToValueTuple<T1,T2,T3>(Tuple<T1,T2,T3>)	Konwertuje wystąpienie `Tuple` klasy na wystąpienie `ValueTuple` struktury.

Dotyczy

Udostępnij za pośrednictwem