Tuple Klasa

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

Tuple.cs

Udostępnia metody statyczne do tworzenia obiektów krotki.

public ref class Tuple abstract sealed

public static class Tuple

type Tuple = class

Public Class Tuple

Dziedziczenie

Object

Tuple

Przykłady

Poniższy przykład tworzy krotkę 8-krotkową (ósemkę), która zawiera liczby pierwsze, które są mniejsze niż 20.

var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1);
// The example displays the following output:
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

open System

let primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
printfn $"Prime numbers less than 20: {primes.Item1}, {primes.Item2}, {primes.Item3}, {primes.Item4}, {primes.Item5}, {primes.Item6}, {primes.Item7}, and {primes.Rest.Item1}"
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Dim primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1)
' The example displays the following output:
'     Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Uwagi

Krotka to struktura danych, która ma określoną liczbę i sekwencję elementów. Przykładem krotki jest struktura danych z trzema elementami (znanymi jako krotka 3-krotka lub potrójna), która jest używana do przechowywania identyfikatora, takiego jak nazwisko osoby w pierwszym elemplecie, rok w drugim elemple i dochód osoby za ten rok w trzecim elemple. Program .NET Framework bezpośrednio obsługuje krotki z jednym do siedmiu elementów. Ponadto można tworzyć krotki ośmiu lub więcej elementów, zagnieżdżając obiekty krotki we Rest właściwości Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.

Krotki są często używane na cztery sposoby:

• Aby reprezentować pojedynczy zestaw danych. Na przykład krotka może reprezentować rekord bazy danych, a jego składniki mogą reprezentować poszczególne pola rekordu.

• Aby zapewnić łatwy dostęp do zestawu danych i manipulowanie nimi.

• Aby zwrócić wiele wartości z metody bez używania out parametrów (w języku C#) lub ByRef parametrów (w Visual Basic).

• Aby przekazać wiele wartości do metody za pomocą jednego parametru. Na przykład metoda ma jeden parametr, Thread.Start(Object) który umożliwia podanie jednej wartości do metody wykonywanej przez wątek w czasie uruchamiania. Jeśli podasz obiekt jako argument metody, możesz podać procedurę Tuple<T1,T2,T3> uruchamiania wątku z trzema elementami danych.

Klasa Tuple nie reprezentuje krotki. Zamiast tego jest to klasa, która udostępnia metody statyczne do tworzenia wystąpień typów krotki obsługiwanych przez program .NET Framework. Udostępnia metody pomocnicze, które można wywołać w celu utworzenia wystąpienia obiektów krotki bez konieczności jawnego określania typu każdego składnika krotki.

Chociaż można utworzyć wystąpienie klasy krotki przez wywołanie jego konstruktora klasy, kod do tego może być kłopotliwy. W poniższym przykładzie użyto konstruktora klasy do utworzenia krotki lub przegrody zawierającej dane populacji dla Nowego Jorku dla każdego spisu od 1950 do 2000 roku.

// Create a 7-tuple.
var population = new Tuple<string, int, int, int, int, int, int>(
                           "New York", 7891957, 7781984, 
                           7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple<string, int, int, int, int, int, int>(
                            "New York", 7891957, 7781984, 
                            7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer) _
                           ("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

Tworzenie tego samego obiektu krotki przy użyciu metody pomocniczej jest prostsze, jak pokazano w poniższym przykładzie.

// Create a 7-tuple.
var population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

Metody Create pomocnicze bezpośrednio obsługują tworzenie obiektów krotki, które mają od jednego do ośmiu składników (czyli pojedynczych w oktetach). Chociaż nie ma praktycznego ograniczenia liczby składników, które może mieć krotka, metody pomocnika nie są dostępne do utworzenia krotki z dziewięciu lub więcej składników. Aby utworzyć taką krotkę, należy wywołać Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> konstruktor.

Uwaga / Notatka

Aby uzyskać dodatkowe informacje i przykłady korzystające z krotki, zobacz dokumentację poszczególnych typów krotki w programie .NET Framework. Są one wymienione w sekcji Zobacz również na końcu tego tematu.

Metody

Nazwa	Opis
Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)	Tworzy nową krotkę 8-krotkową lub ósemkę.
Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)	Tworzy nową krotkę 7-krotkową lub przegrodę.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Tworzy nową krotkę 6-krotkową lub sekstuple.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)	Tworzy nową krotkę 5-krotkową lub kwintuple.
Create<T1,T2,T3,T4>(T1, T2, T3, T4)	Tworzy nową krotkę 4-krotkową lub czteroosobową.
Create<T1,T2,T3>(T1, T2, T3)	Tworzy nową krotkę 3-krotkową lub potrójną.
Create<T1,T2>(T1, T2)	Tworzy nową krotkę 2-krotkową lub parę.
Create<T1>(T1)	Tworzy nową krotkę 1 lub pojedynczą.

Zobacz też

• Tuple<T1>
• Tuple<T1,T2>
• Tuple<T1,T2,T3>
• Tuple<T1,T2,T3,T4>
• Tuple<T1,T2,T3,T4,T5>
• Tuple<T1,T2,T3,T4,T5,T6>
• Tuple<T1,T2,T3,T4,T5,T6,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>