Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 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ę n, gdzie n ma wartość 8 lub większą.

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TRest>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

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

public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

[System.Serializable]
public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'Rest> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple

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

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

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7, TRest)
Implements IComparable, IStructuralComparable, IStructuralEquatable

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7, TRest)
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.

T4

Typ czwartego składnika spójnej kolekcji.

T5

Typ piątego składnika spójnej kolekcji.

T6

Typ szóstego składnika krotki.

T7

Typ siódmego składnika krotki.

TRest

Każdy obiekt ogólny Tuple , który definiuje typy pozostałych składników krotki.

Dziedziczenie: Object
Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

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,T4,T5,T6,T7,TRest> reprezentuje krotkę n zawierającą co najmniej osiem składników.

Można utworzyć Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> wystąpienie obiektu z dokładnie ośmioma składnikami, wywołując metodę statyczną Tuple.Create . Poniższy przykład tworzy krotkę 8-krotkową (ósemkę), która zawiera liczby pierwsze, które są mniejsze niż 20. Należy pamiętać, że używa wnioskowania typu do określania typu każdego składnika.

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

Można również utworzyć wystąpienie obiektu n-krotki z ośmioma lub większą większa większa liczba składników przez wywołanie konstruktora Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . W poniższym przykładzie użyto konstruktora Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> do utworzenia 8-krotki, która jest odpowiednikiem krotki utworzonej w poprzednim przykładzie.

var primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
             Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19));

let primes = new Tuple<Int32, Int32, Int32, Int32, Int32, Int32, Int32,  
               Tuple<Int32>> (2, 3, 5, 7, 11, 13, 17, new Tuple<Int32>(19))

Dim primes = New Tuple(Of Int32, Int32, Int32, Int32, Int32, Int32, Int32, _ 
             Tuple(Of Int32))(2, 3, 5, 7, 11, 13, 17, New Tuple(Of Int32)(19))

Uwaga

Aby utworzyć n-krotkę z co najmniej dziewięcioma Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> składnikami, należy wywołać konstruktora. Metody statycznej Tuple fabryki klasy nie obsługują tworzenia Tuple obiektów z ponad ośmioma składnikami.

Aby utworzyć wystąpienie n-krotki zawierającej osiem lub więcej składników za pomocą Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> konstruktora, należy podać obiekt ogólny Tuple jako rest parametr, aby zdefiniować ósmy za pomocą n-tych składników krotki. Zagnieżdżając obiekty ogólne Tuple w ten sposób, można utworzyć krotkę, która nie ma praktycznego ograniczenia liczby jego składników.

Poniższy przykład obejmuje tworzenie 17-krotki zawierającej dane dotyczące populacji miasta Detroit w stanie Michigan dla każdego narodowego spisu powszechnego od 1860 do 2000 roku. Pierwszym składnikiem krotki jest nazwa miasta. Drugi składnik to data rozpoczęcia serii danych, a trzeci składnik to populacja w dacie początkowej. Każdy kolejny składnik zapewnia populację w interwałach dekad. Krotka 17 jest tworzona przez zagnieżdżanie Tuple<T1,T2,T3> obiektu wewnątrz Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu. (Oznacza to, Tuple<T1,T2,T3> że obiekt jest dostarczany jako wartość parametru rest w konstruktorze Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> klasy). Ten Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiekt jest z kolei zagnieżdżony w obiekcie zewnętrznym Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . (Oznacza to, Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> że obiekt jest dostarczany jako wartość parametru rest w konstruktorze klasy obiektu zewnętrznego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> ).

var from1980 = Tuple.Create(1203339, 1027974, 951270);
var from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>> 
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980);
var population = new Tuple<string, int, int, int, int, int, int,
    Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>> 
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910);

let from1980 = Tuple.Create(1203339, 1027974, 951270)
let from1910 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>(465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
let population = new Tuple<string, int, int, int, int, int, int, Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>>("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Dim from1980 = Tuple.Create(1203339, 1027974, 951270)
Dim from1910 As New Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, _
    Tuple(Of Integer, Integer, Integer)) _
    (465766, 993078, 1568622, 1623452, 1849568, 1670144, 1511462, from1980)
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer, _ 
    Tuple(Of Integer, Integer, Integer, Integer, Integer, Integer, Integer, Tuple(Of Integer, Integer, Integer))) _
    ("Detroit", 1860, 45619, 79577, 116340, 205876, 285704, from1910)

Wartość pierwszych siedmiu składników kolekcji można pobrać przy użyciu właściwości wystąpienia tylko Item1do odczytu, Item4 Item3 Item5 Item2, Item6i .Item7 Wszystkie dodatkowe składniki są zagnieżdżone i można je pobrać z Rest właściwości . W poprzednim przykładzie Item1 właściwości through Item7 pobierają pierwsze przez siódme składniki spójnej kolekcji. Ósme do czternastego składnika znajdują się w krotki zagnieżdżonej na drugim poziomie i są reprezentowane przez Rest.Item1 właściwości przez Rest.Item7 . Piętnaście do siedemnastu składników znajduje się w krotki zagnieżdżonej na trzecim poziomie i są reprezentowane przez Rest.Rest.Item1 właściwości choć Rest.Rest.Item3 .

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.
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 obliczone statystyki wraz z nazwą miasta w Tuple<T1,T2,T3,T4,T5,T6,T7> 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 Tuple<T1,T2,T3,T4,T5,T6,T7> obiekt jako argument metody, możesz podać procedurę uruchamiania wątku z siedmioma elementami danych.

Konstruktory

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

Inicjuje nowe wystąpienie klasy Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Właściwości

Item1	Pobiera wartość pierwszego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item2	Pobiera wartość drugiego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item3	Pobiera wartość trzeciego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item4	Pobiera wartość czwartego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item5	Pobiera wartość piątego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item6	Pobiera wartość szóstego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Item7	Pobiera wartość siódmego składnika bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.
Rest	Pobiera pozostałe składniki bieżącego Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> obiektu.

Metody

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

Jawne implementacje interfejsu

IComparable.CompareTo(Object)	Porównuje bieżący Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 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,T4,T5,T6,T7,TRest> obiekt z określonym obiektem przy użyciu określonego porównania i zwraca liczbę całkowitą, która wskazuje, czy bieżący obiekt jest 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,T4,T5,T6,T7,TRest> 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,T4,T5,T6,T7,TRest> 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`.

Dotyczy