Tuple Klasa

Definicja

Przestrzeń nazw:

System

Zestaw:

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 służy do przechowywania identyfikatora, takiego jak nazwisko osoby w pierwszym elemecie, rok w drugim elemecie i dochód osoby za ten rok w trzecim elemple. .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 przez zagnieżdżanie obiektów 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:

• 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.

• 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).

• 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 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 .NET Framework. Udostępnia metody pomocnicze, które można wywołać w celu utworzenia wystąpień 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 7-krotki lub septuple zawierającej dane populacji dla Nowego Jorku dla każdego spisu od 1950 do 2000.

// 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 bardziej proste, 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

Create Metody pomocnicze bezpośrednio obsługują tworzenie obiektów krotki, które mają od jednego do ośmiu składników (czyli pojedynczych za pośrednictwem oktetów). Chociaż nie ma praktycznego limitu liczby składników, które może mieć krotka, metody pomocnicze nie są dostępne do utworzenia krotki z dziewięcioma lub większą liczbą 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

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

Metody

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 septuple.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Tworzy nową krotkę 6-krotkową lub sextuple.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)	Tworzy nową krotkę 5-krotkową lub kwintesencję.
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>