TupleExtensions.Deconstruct Methode

Definition

Namespace:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.ValueTuple.dll

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.

Deconiert die Komponenten eines Tupels in separate Variablen.

Überlädt

Name	Beschreibung
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19,T20,T21>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8, T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20,T21>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)	Deconiert ein Tupel mit 21 Elementen in separate Variablen.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19,T20>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10, T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)	Deconstructs a tupel with 20 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11, T12,T13,T14,Tuple<T15,T16,T17,T18,T19>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)	Deconstructs a tupel with 19 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12, T13,T14,Tuple<T15,T16,T17,T18>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)	Deconstructs a tupel with 18 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13, T14,Tuple<T15,T16,T17>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)	Deconstructs a tupel with 17 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14, Tuple<T15,T16>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)	Deconiert ein Tupel mit 16 Elementen in separate Variablen.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)	Deconiert ein Tupel mit 15 Elementen in separate Variablen.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)	Deconstructs a tuple with 14 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)	Deconiert ein Tupel mit 13 Elementen in separate Variablen.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)	Deconstructs a tuple with 12 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)	Deconstructs a tupel with 11 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)	Deconstructs a tupel with 10 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9>>, T1, T2, T3, T4, T5, T6, T7, T8, T9)	Deconiert ein Tupel mit 9 Elementen in separate Variablen.
Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8>>, T1, T2, T3, T4, T5, T6, T7, T8)	Deconstructs a tuple with 8 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6,T7>(Tuple<T1,T2,T3,T4,T5,T6,T7>, T1, T2, T3, T4, T5, T6, T7)	Deconstructs a tupel with 7 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Deconstructs a tupel with 6 elements into separate variables.
Deconstruct<T1,T2,T3,T4,T5>(Tuple<T1,T2,T3,T4,T5>, T1, T2, T3, T4, T5)	Deconstructs a tupel with 5 elements into separate variables.
Deconstruct<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>, T1, T2, T3, T4)	Deconstructs a tupel with 4 elements into separate variables.
Deconstruct<T1,T2,T3>(Tuple<T1,T2,T3>, T1, T2, T3)	Deconstructs a tupel with 3 elements into separate variables.
Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)	Deconstructs a tupel with 2 elements into separate variables.
Deconstruct<T1>(Tuple<T1>, T1)	Deconstructs a tuple with 1 element into a separate variable.

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19,T20,T21>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8, T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20,T21>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconiert ein Tupel mit 21 Elementen in separate Variablen.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16, [Runtime::InteropServices::Out] T17 % item17, [Runtime::InteropServices::Out] T18 % item18, [Runtime::InteropServices::Out] T19 % item19, [Runtime::InteropServices::Out] T20 % item20, [Runtime::InteropServices::Out] T21 % item21);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20,T21>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20, out T21 item21);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 * 'T20 * 'T21 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 * 'T20 * 'T21 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16, T17, T18, T19, T20, T21))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16, ByRef item17 As T17, ByRef item18 As T18, ByRef item19 As T19, ByRef item20 As T20, ByRef item21 As T21)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

T17

Der Typ des siebzehnten Elements.

T18

Der Typ des achtzehnten Elements.

T19

Der Typ des neunzehnten Elements.

T20

Der Typ des zwanzigsten Elements.

T21

Der Typ des 201. Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20,T21>>>

Das 21-Element-Tupel zum Deconieren in 21 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

item17: T17

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebzehnten Elements oder value.Rest.Rest.Item3.

item18: T18

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achtzehnten Elements oder value.Rest.Rest.Item4.

item19: T19

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunzehnten Elements oder value.Rest.Rest.Item5.

item20: T20

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwanzigsten Elements oder value.Rest.Rest.Item6.

item21: T21

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des 20.10.-Elements oder value.Rest.Rest.Item7.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Da die .NET Framework-Tupeltypen Tupel mit mehr als 7 Elementen implementieren, indem ein Tupel in Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest geschachtelt wird, sind item8 bis item21 Elemente geschachtelter Tupel.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19,T20>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10, T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 20 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16, [Runtime::InteropServices::Out] T17 % item17, [Runtime::InteropServices::Out] T18 % item18, [Runtime::InteropServices::Out] T19 % item19, [Runtime::InteropServices::Out] T20 % item20);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 * 'T20 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 * 'T20 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16, T17, T18, T19, T20))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16, ByRef item17 As T17, ByRef item18 As T18, ByRef item19 As T19, ByRef item20 As T20)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

T17

Der Typ des siebzehnten Elements.

T18

Der Typ des achtzehnten Elements.

T19

Der Typ des neunzehnten Elements.

T20

Der Typ des zwanzigsten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19,T20>>>

Das 20-Element-Tupel zum Deconieren in 20 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

item17: T17

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebzehnten Elements oder value.Rest.Rest.Item3.

item18: T18

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achtzehnten Elements oder value.Rest.Rest.Item4.

item19: T19

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunzehnten Elements oder value.Rest.Rest.Item5.

item20: T20

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwanzigsten Elements oder value.Rest.Rest.Item6.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18,T19>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11, T12,T13,T14,Tuple<T15,T16,T17,T18,T19>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 19 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16, [Runtime::InteropServices::Out] T17 % item17, [Runtime::InteropServices::Out] T18 % item18, [Runtime::InteropServices::Out] T19 % item19);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T19 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16, T17, T18, T19))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16, ByRef item17 As T17, ByRef item18 As T18, ByRef item19 As T19)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

T17

Der Typ des siebzehnten Elements.

T18

Der Typ des achtzehnten Elements.

T19

Der Typ des neunzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18,T19>>>

Das 19-Element-Tupel zum Deconieren in 19 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

item17: T17

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebzehnten Elements oder value.Rest.Rest.Item3.

item18: T18

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achtzehnten Elements oder value.Rest.Rest.Item4.

item19: T19

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunzehnten Elements oder value.Rest.Rest.Item5.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17,T18>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12, T13,T14,Tuple<T15,T16,T17,T18>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 18 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16, [Runtime::InteropServices::Out] T17 % item17, [Runtime::InteropServices::Out] T18 % item18);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T18 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16, T17, T18))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16, ByRef item17 As T17, ByRef item18 As T18)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

T17

Der Typ des siebzehnten Elements.

T18

Der Typ des achtzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17,T18>>>

Das 18-Element-Tupel zum Deconieren in 18 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

item17: T17

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebzehnten Elements oder value.Rest.Rest.Item3.

item18: T18

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achtzehnten Elements oder value.Rest.Rest.Item4.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16,T17>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13, T14,Tuple<T15,T16,T17>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 17 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16, [Runtime::InteropServices::Out] T17 % item17);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T17 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16, T17))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16, ByRef item17 As T17)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

T17

Der Typ des siebzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16,T17>>>

Das Tupel mit 17 Elementen, das in 17 separate Variablen deconiert werden soll.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

item17: T17

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebzehnten Elements oder value.Rest.Rest.Item3.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15, T16>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14, Tuple<T15,T16>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconiert ein Tupel mit 16 Elementen in separate Variablen.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15, [Runtime::InteropServices::Out] T16 % item16);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15, T16))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15, ByRef item16 As T16)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

T16

Der Typ des sechzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15,T16>>>

Das 16-Element-Tupel zum Deconieren in 16 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

item16: T16

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechzehnten Elements oder value.Rest.Rest.Item2.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15>>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconiert ein Tupel mit 15 Elementen in separate Variablen.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15> ^> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14, [Runtime::InteropServices::Out] T15 % item15);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14, Tuple(Of T15))), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14, ByRef item15 As T15)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

T15

Der Typ des fünfzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14,Tuple<T15>>>

Das 15-Element-Tupel zum Deconieren in 15 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

item15: T15

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünfzehnten Elements oder value.Rest.Rest.Item1.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tuple with 14 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13, [Runtime::InteropServices::Out] T14 % item14);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13, T14)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13, ByRef item14 As T14)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

T14

Der Typ des vierzehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13,T14>>

Das 14-Element-Tupel zum Deconieren in 14 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

item14: T14

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierzehnten Elements oder value.Rest.Item7.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconiert ein Tupel mit 13 Elementen in separate Variablen.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12, [Runtime::InteropServices::Out] T13 % item13);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12, T13)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12, ByRef item13 As T13)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

T13

Der Typ des dreizehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12,T13>>

Das 13-Element-Tupel zum Deconieren in 13 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

item13: T13

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dreizehnten Elements oder value.Rest.Item6.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(Tuple<T1, T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tuple with 12 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11, [Runtime::InteropServices::Out] T12 % item12);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11, T12)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11, ByRef item12 As T12)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

T12

Der Typ des zwölften Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11,T12>>

Das 12-Element-Tupel zum Deconieren in 12 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

item12: T12

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zwölften Elements oder value.Rest.Item5.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 11 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10, [Runtime::InteropServices::Out] T11 % item11);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10, T11)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10, ByRef item11 As T11)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

T11

Der Typ des elften Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10,T11>>

Das 11-Element-Tupel zum Deconieren in 11 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

item11: T11

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des elften Elements oder value.Rest.Item4.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10>>, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 10 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9, [Runtime::InteropServices::Out] T10 % item10);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9, T10)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9, ByRef item10 As T10)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

T10

Der Typ des zehnten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9,T10>>

Das 10-Element-Tupel zum Deconieren in 10 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

item10: T10

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zehnten Elements oder value.Rest.Item3.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9>(Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9>>, T1, T2, T3, T4, T5, T6, T7, T8, T9)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconiert ein Tupel mit 9 Elementen in separate Variablen.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8, [Runtime::InteropServices::Out] T9 % item9);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8,T9>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8, T9) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8, T9)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8, ByRef item9 As T9)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

T9

Der Typ des neunten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8,T9>>

Das 9-Element-Tupel zum Deconieren in 9 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

item9: T9

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des neunten Elements oder value.Rest.Item2.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Da die tupeltypen .NET Framework Tupel mit mehr als 7 Elementen implementieren, indem ein Tupel in Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest geschachtelt wird, sind item8 und item9 Elemente geschachtelter Tupel.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tuple with 8 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8> ^> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7, [Runtime::InteropServices::Out] T8 % item8);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7,T8>(this Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7, T8) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7, ByRef item8 As T8)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

T8

Der Typ des achten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7,Tuple<T8>>

Das 8-Element-Tupel zum Deconieren in 8 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

item8: T8

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des achten Elements oder value.Rest.Item1.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Da die .NET Framework-Tupel-Typen Tupel mit mehr als 7 Elementen implementieren, indem ein Tupel in Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest geschachtelt wird, ist item8 ein Element in einem geschachtelten Tupel.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 7 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6, T7> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6, [Runtime::InteropServices::Out] T7 % item7);

public static void Deconstruct<T1,T2,T3,T4,T5,T6,T7>(this Tuple<T1,T2,T3,T4,T5,T6,T7> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6, T7) (value As Tuple(Of T1, T2, T3, T4, T5, T6, T7), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6, ByRef item7 As T7)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

T7

Der Typ des siebten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6,T7>

Das 7-Element-Tupel zum Deconieren in 7 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

item7: T7

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des siebten Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 6 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5, T6> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5, [Runtime::InteropServices::Out] T6 % item6);

public static void Deconstruct<T1,T2,T3,T4,T5,T6>(this Tuple<T1,T2,T3,T4,T5,T6> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5, T6) (value As Tuple(Of T1, T2, T3, T4, T5, T6), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5, ByRef item6 As T6)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

T6

Der Typ des sechsten Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5,T6>

Das 6-Element-Tupel zum Deconieren in 6 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

item6: T6

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des sechsten Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1,T2,T3,T4,T5>(Tuple<T1,T2,T3,T4,T5>, T1, T2, T3, T4, T5)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 5 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4, typename T5>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4, T5> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4, [Runtime::InteropServices::Out] T5 % item5);

public static void Deconstruct<T1,T2,T3,T4,T5>(this Tuple<T1,T2,T3,T4,T5> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T1 * 'T2 * 'T3 * 'T4 * 'T5 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4, T5) (value As Tuple(Of T1, T2, T3, T4, T5), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4, ByRef item5 As T5)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

T5

Der Typ des fünften Elements.

Parameter

value: Tuple<T1,T2,T3,T4,T5>

Das 5-Element-Tupel zum Deconieren in 5 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

item5: T5

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des fünften Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 4 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3, typename T4>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3, T4> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3, [Runtime::InteropServices::Out] T4 % item4);

public static void Deconstruct<T1,T2,T3,T4>(this Tuple<T1,T2,T3,T4> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T4 * 'T1 * 'T2 * 'T3 * 'T4 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3, T4) (value As Tuple(Of T1, T2, T3, T4), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3, ByRef item4 As T4)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

T4

Der Typ des vierten Elements.

Parameter

value: Tuple<T1,T2,T3,T4>

Das 4-Element-Tupel zum Deconieren in 4 separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

item4: T4

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des vierten Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 3 elements into separate variables.

public:
generic <typename T1, typename T2, typename T3>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2, T3> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2, [Runtime::InteropServices::Out] T3 % item3);

public static void Deconstruct<T1,T2,T3>(this Tuple<T1,T2,T3> value, out T1 item1, out T2 item2, out T3 item3);

static member Deconstruct : 'T1 * 'T2 * 'T3 * 'T1 * 'T2 * 'T3 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2, T3) (value As Tuple(Of T1, T2, T3), ByRef item1 As T1, ByRef item2 As T2, ByRef item3 As T3)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

T3

Der Typ des dritten Elements.

Parameter

value: Tuple<T1,T2,T3>

Das 3-Element-Tupel, das in 3 separate Variablen destrukturiert werden soll.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

item3: T3

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des dritten Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

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

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tupel with 2 elements into separate variables.

public:
generic <typename T1, typename T2>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1, T2> ^ value, [Runtime::InteropServices::Out] T1 % item1, [Runtime::InteropServices::Out] T2 % item2);

public static void Deconstruct<T1,T2>(this Tuple<T1,T2> value, out T1 item1, out T2 item2);

static member Deconstruct : 'T1 * 'T2 * 'T1 * 'T2 -> unit

<Extension()>
Public Sub Deconstruct(Of T1, T2) (value As Tuple(Of T1, T2), ByRef item1 As T1, ByRef item2 As T2)

Typparameter

T1

Der Typ des ersten Elements.

T2

Der Typ des zweiten Elements.

Parameter

value: Tuple<T1,T2>

Das 2-Element-Tupel zum Deconieren in zwei separate Variablen.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des ersten Elements.

item2: T2

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des zweiten Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Deconstruct<T1>(Tuple<T1>, T1)

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Quelle:: TupleExtensions.cs

Deconstructs a tuple with 1 element into a separate variable.

public:
generic <typename T1>
[System::Runtime::CompilerServices::Extension]
 static void Deconstruct(Tuple<T1> ^ value, [Runtime::InteropServices::Out] T1 % item1);

public static void Deconstruct<T1>(this Tuple<T1> value, out T1 item1);

static member Deconstruct : 'T1 * 'T1 -> unit

<Extension()>
Public Sub Deconstruct(Of T1) (value As Tuple(Of T1), ByRef item1 As T1)

Typparameter

T1

Der Typ des einzelnen Elements.

Parameter

value: Tuple<T1>

Das 1-Element-Tupel, das in eine separate Variable deconiert werden soll.

item1: T1

Wenn diese Methode zurückgegeben wird, enthält sie den Wert des einzelnen Elements.

Hinweise

Diese Methode wird in erster Linie implementiert, um die Tupelsprachenfeatures in C# zu unterstützen.

Weitere Informationen

Gilt für:

Feedback

War diese Seite hilfreich?