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

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt ein n-Tupel mit n größer oder gleich 8 dar.

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

Typparameter

T1

Der Typ der ersten Komponente des Tupels.

T2

Der Typ der zweiten Komponente des Tupels.

T3

Der Typ der dritten Komponente des Tupels.

T4

Der Typ der vierten Komponente des Tupels.

T5

Der Typ der fünften Komponente des Tupels.

T6

Der Typ der sechsten Komponente des Tupels.

T7

Der Typ der siebten Komponente des Tupels.

TRest

Ein beliebiges generisches Tuple-Objekt, das die Typen der restlichen Komponenten des Tupels definiert.

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

Attribute: SerializableAttribute

Implementiert: IStructuralComparable IStructuralEquatable IComparable ITuple

Hinweise

Ein Tuple ist eine Datenstruktur, die eine bestimmte Anzahl und Sequenz von Werten aufweist. Die Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Klasse stellt ein n-Tuple dar, das acht oder mehr Komponenten enthält.

Sie können ein Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekt mit genau acht Komponenten instanziieren, indem Sie die statische Tuple.Create Methode aufrufen. Im folgenden Beispiel wird ein 8-Tuple (Oktuple) erstellt, das Primzahlen enthält, die kleiner als 20 sind. Beachten Sie, dass die Typzuleitung verwendet wird, um den Typ jeder Komponente zu bestimmen.

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

Sie können auch ein n-tuple-Objekt mit acht oder mehr Komponenten instanziieren, indem Sie den Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Konstruktor aufrufen. Im folgenden Beispiel wird der Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Konstruktor verwendet, um ein 8-Tuple zu erstellen, das dem in dem vorherigen Beispiel erstellten Tuple entspricht.

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

Hinweis

Um ein n-Tuple mit neun oder mehr Komponenten zu erstellen, müssen Sie den Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Konstruktor aufrufen. Die statischen Fabrikmethoden der Tuple Klasse unterstützen die Erstellung von Tuple Objekten mit mehr als acht Komponenten nicht.

Um ein n-Tuple mit acht oder mehr Komponenten mit dem Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Konstruktor instanziieren zu können, geben Sie ein generisches Tuple Objekt als rest Parameter an, um die achte bis nth-Komponenten des Tuples zu definieren. Indem Sie generische Tuple Objekte auf diese Weise verschachteln, können Sie ein Tuple erstellen, das keine praktische Einschränkung der Anzahl seiner Komponenten aufweist.

Im folgenden Beispiel wird ein 17-Tuple erstellt, das Bevölkerungsdaten für die Stadt Detroit, Michigan, für jede nationale Volkszählung von 1860 bis 2000 enthält. Die erste Komponente des Tuples ist der Name der Stadt. Die zweite Komponente ist das Anfangsdatum der Datenreihe, und die dritte Komponente ist die Grundzahl am Anfangsdatum. Jede nachfolgende Komponente stellt die Bevölkerung in Zehnzehnzeitintervallen bereit. Das 17-Tuple wird erstellt, indem ein Objekt innerhalb eines Tuple<T1,T2,T3> Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekts geschachtelt wird. (Das heißt, das Tuple<T1,T2,T3> Objekt wird als Wert des rest Parameters im Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Klassenkonstruktor angegeben.) Dieses Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekt ist wiederum in einem äußeren Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekt geschachtelt. (Das heißt, das Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekt wird als Wert des rest Parameters im Klassenkonstruktor des äußeren Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekts angegeben.)

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)

Sie können den Wert der ersten sieben Komponenten des Tuples abrufen, indem Sie die schreibgeschützten Item1, Item2 Item5 Item6 Item3 Item4und Item7 Instanzeigenschaften verwenden. Alle zusätzlichen Komponenten werden geschachtelt und können aus der Rest Eigenschaft abgerufen werden. Im vorherigen Beispiel rufen die Item1 Item7 Durchlaufeigenschaften die ersten bis siebten Komponenten des Tuples ab. Die acht bis 19. Komponenten sind in der Tuple enthalten, die auf der zweiten Ebene geschachtelt ist, und werden durch die Rest.Item1 Rest.Item7 durch die Eigenschaften dargestellt. Die fünfzehnten bis siebenzehnten Komponenten sind in der Tuple enthalten, die auf der dritten Ebene geschachtelt ist, und werden durch die Rest.Rest.Item1 Rest.Rest.Item3 eigenschaften dargestellt.

Tuples werden häufig auf vier verschiedene Arten verwendet:

So stellen Sie eine einzelne Gruppe von Daten dar. Beispielsweise kann ein Tuple einen Datenbankdatensatz darstellen, und seine Komponenten können einzelne Felder des Datensatzes darstellen.
Um einen einfachen Zugriff auf und die Manipulation eines Datensatzes zu ermöglichen.
Um mehrere Werte aus einer Methode ohne Verwendung von out Parametern (in C#) oder ByRef Parametern (in Visual Basic) zurückzugeben. Das vorherige Beispiel gibt beispielsweise seine berechneten Statistiken zusammen mit dem Stadtnamen in einem Tuple<T1,T2,T3,T4,T5,T6,T7> Objekt zurück.
So übergeben Sie mehrere Werte an eine Methode über einen einzelnen Parameter. Die Methode verfügt beispielsweise Thread.Start(Object) über einen einzelnen Parameter, mit dem Sie einen Wert für die Methode angeben können, die der Thread beim Start ausführt. Wenn Sie ein Tuple<T1,T2,T3,T4,T5,T6,T7> Objekt als Methodenargument angeben, können Sie die Startroutine des Threads mit sieben Datenelementen angeben.

Konstruktoren

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

Initialisiert eine neue Instanz der Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Klasse.

Eigenschaften

Item1	Ruft den Wert der ersten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item2	Ruft den Wert der zweiten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item3	Ruft den Wert der dritten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item4	Ruft den Wert der vierten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item5	Ruft den Wert der fünften Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item6	Ruft den Wert der sechsten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Item7	Ruft den Wert der siebten Komponente des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.
Rest	Ruft die restlichen Komponenten des aktuellen Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekts ab.

Methoden

Equals(Object)	Gibt einen Wert zurück, der angibt, ob das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt gleich einem angegebenen Objekt ist.
GetHashCode()	Berechnet den Hashcode für das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die den Wert dieser Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Instanz darstellt.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)	Vergleicht das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt mit einem angegebenen Objekt und gibt eine Ganzzahl zurück, die darauf hinweist, ob sich das aktuelle Objekt in der Sortierreihenfolge vor oder hinter dem angegebenen Objekt oder an der gleichen Position befindet.
IStructuralComparable.CompareTo(Object, IComparer)	Vergleicht das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt anhand eines angegebenen Vergleichs mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob sich das aktuelle Element in der Sortierreihenfolge vor dem angegebenen Element, dahinter oder an derselben Position befindet.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Gibt einen Wert zurück, der auf Grundlage einer angegebenen Vergleichsmethode angibt, ob das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt gleich einem angegebenen Objekt ist.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Berechnet mit einer angegebenen Berechnungsmethode den Hash für das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt.
ITuple.Item[Int32]	Ruft den Wert des angegebenen Elements `Tuple` ab.
ITuple.Length	Ruft die Anzahl der Elemente im `Tuple` ab.

Gilt für