TupleExtensions.Deconstruct Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: System.ValueTuple.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Deconstruye los componentes de una tupla en variables independientes.

Sobrecargas

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)	Deconstruye una tupla con 21 elementos en variables independientes.
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)	Deconstruye una tupla con 20 elementos en variables independientes.
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)	Deconstruye una tupla con 19 elementos en variables independientes.
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)	Deconstruye una tupla con 18 elementos en variables independientes.
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)	Deconstruye una tupla con 17 elementos en variables independientes.
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)	Deconstruye una tupla con 16 elementos en variables independientes.
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)	Deconstruye una tupla con 15 elementos en variables independientes.
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)	Deconstruye una tupla con 14 elementos en variables independientes.
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)	Deconstruye una tupla con 13 elementos en variables independientes.
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)	Deconstruye una tupla con 12 elementos en variables independientes.
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)	Deconstruye una tupla con 11 elementos en variables independientes.
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)	Deconstruye una tupla con 10 elementos en variables independientes.
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)	Deconstruye una tupla con nueve elementos en variables independientes.
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)	Deconstruye una tupla con ocho elementos en variables independientes.
Deconstruct<T1,T2,T3,T4,T5,T6,T7>(Tuple<T1,T2,T3,T4,T5,T6,T7>, T1, T2, T3, T4, T5, T6, T7)	Deconstruye una tupla con siete elementos en variables independientes.
Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Deconstruye una tupla con seis elementos en variables independientes.
Deconstruct<T1,T2,T3,T4,T5>(Tuple<T1,T2,T3,T4,T5>, T1, T2, T3, T4, T5)	Deconstruye una tupla con cinco elementos en variables independientes.
Deconstruct<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>, T1, T2, T3, T4)	Deconstruye una tupla con cuatro elementos en variables independientes.
Deconstruct<T1,T2,T3>(Tuple<T1,T2,T3>, T1, T2, T3)	Deconstruye una tupla con tres elementos en variables independientes.
Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)	Deconstruye una tupla con dos elementos en variables independientes.
Deconstruct<T1>(Tuple<T1>, T1)	Deconstruye una tupla con un elemento en una variable independiente.

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 21 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

T17

El tipo del decimoséptimo elemento.

T18

El tipo del decimoctavo elemento.

T19

El tipo del decimonoveno elemento.

T20

El tipo del vigésimo elemento.

T21

El tipo del vigésimo primer elemento.

Parámetros

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

La tupla de 21 elementos que se deconstruirá en 21 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método vuelve, contiene el valor del decimosexto elemento, o value.Rest.Rest.Item2.

item17: T17

Cuando este método devuelve , contiene el valor del diecisiete elemento o value.Rest.Rest.Item3.

item18: T18

Cuando este método devuelve , contiene el valor del decimoctavo elemento o value.Rest.Rest.Item4.

item19: T19

Cuando este método devuelve , contiene el valor del decimonoveno elemento o value.Rest.Rest.Item5.

item20: T20

Cuando este método devuelve , contiene el valor del elemento xx o value.Rest.Rest.Item6.

item21: T21

Cuando este método devuelve , contiene el valor del veintiuno primer elemento, o value.Rest.Rest.Item7.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item21 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 20 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

T17

El tipo del decimoséptimo elemento.

T18

El tipo del decimoctavo elemento.

T19

El tipo del decimonoveno elemento.

T20

El tipo del vigésimo elemento.

Parámetros

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

La tupla de 20 elementos que se deconstruirá en 20 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método devuelve , contiene el valor del decimosexto elemento o value.Rest.Rest.Item2.

item17: T17

Cuando este método devuelve , contiene el valor del diecisiete elemento o value.Rest.Rest.Item3.

item18: T18

Cuando este método devuelve , contiene el valor del decimoctavo elemento o value.Rest.Rest.Item4.

item19: T19

Cuando este método devuelve , contiene el valor del decimonoveno elemento o value.Rest.Rest.Item5.

item20: T20

Cuando este método devuelve , contiene el valor del vigésimo elemento o value.Rest.Rest.Item6.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 19 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

T17

El tipo del decimoséptimo elemento.

T18

El tipo del decimoctavo elemento.

T19

El tipo del decimonoveno elemento.

Parámetros

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

La tupla de 19 elementos que se deconstruirá en 19 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método devuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método devuelve , contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método devuelve , contiene el valor del decimosexto elemento o value.Rest.Rest.Item2.

item17: T17

Cuando este método devuelve , contiene el valor del diecisiete elemento o value.Rest.Rest.Item3.

item18: T18

Cuando este método devuelve , contiene el valor del decimoctavo elemento o value.Rest.Rest.Item4.

item19: T19

Cuando este método devuelve , contiene el valor del decimonoveno elemento o value.Rest.Rest.Item5.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 mediante item19 son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 18 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

T17

El tipo del decimoséptimo elemento.

T18

El tipo del decimoctavo elemento.

Parámetros

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

La tupla de 18 elementos que se deconstruirá en 18 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método devuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método devuelve , contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método devuelve , contiene el valor del decimosexto elemento o value.Rest.Rest.Item2.

item17: T17

Cuando este método devuelve , contiene el valor del diecisiete elemento o value.Rest.Rest.Item3.

item18: T18

Cuando este método devuelve , contiene el valor del decimoctavo elemento o value.Rest.Rest.Item4.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 17 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

T17

El tipo del decimoséptimo elemento.

Parámetros

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

La tupla de 17 elementos que se deconstruirá en 17 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método vuelve, contiene el valor del decimosexto elemento, o value.Rest.Rest.Item2.

item17: T17

Cuando este método devuelve , contiene el valor del diecisiete elemento o value.Rest.Rest.Item3.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item17 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 16 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

T16

El tipo del decimosexto elemento.

Parámetros

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

La tupla de 16 elementos que se deconstruirá en 16 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

item16: T16

Cuando este método vuelve, contiene el valor del decimosexto elemento, o value.Rest.Rest.Item2.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item16 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 15 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

T15

El tipo del decimoquinto elemento.

Parámetros

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

La tupla de 15 elementos que se deconstruirá en 15 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

item15: T15

Cuando este método devuelve , contiene el valor del decimoquinto elemento o value.Rest.Rest.Item1.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item15 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 14 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

T14

El tipo del decimocuarto elemento.

Parámetros

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

La tupla de 14 elementos que se deconstruirá en 14 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

item14: T14

Cuando este método devuelve , contiene el valor del decimocuarto elemento o value.Rest.Item7.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 13 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

T13

El tipo del decimotercer elemento.

Parámetros

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

La tupla de 13 elementos que se deconstruirá en 13 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

item13: T13

Cuando este método devuelve , contiene el valor del decimotercer elemento o value.Rest.Item6.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item13 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 12 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

T12

El tipo del duodécimo elemento.

Parámetros

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

La tupla de 12 elementos que se deconstruirá en 12 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

item12: T12

Cuando este método devuelve , contiene el valor del duodécimo elemento, o value.Rest.Item5.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item12 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 11 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

T11

El tipo del undécimo elemento.

Parámetros

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

La tupla de 11 elementos que se deconstruirá en 11 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

item11: T11

Cuando este método devuelve , contiene el valor del undécimo elemento o value.Rest.Item4.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item11 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con 10 elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

T10

El tipo del décimo elemento.

Parámetros

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

La tupla de 10 elementos que se deconstruirá en 10 variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

item10: T10

Cuando este método devuelve , contiene el valor del décimo elemento o value.Rest.Item3.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 a través item10 de son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con nueve elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

T9

El tipo del noveno elemento.

Parámetros

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

La tupla de nueve elementos que se deconstruirá en nueve variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

item9: T9

Cuando este método devuelve , contiene el valor del noveno elemento o value.Rest.Item2.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Resty item8item9 son elementos de tuplas anidadas.

Consulte también

Se aplica a

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)

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con ocho elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

T8

El tipo del octavo elemento.

Parámetros

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

La tupla de ocho elementos que se deconstruirá en ocho variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método finaliza, contiene el valor del tercer elemento.

item4: T4

Cuando este método vuelve, contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método vuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método vuelve, contiene el valor del séptimo elemento.

item8: T8

Cuando este método devuelve , contiene el valor del octavo elemento o value.Rest.Item1.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Dado que los tipos de tupla de .NET Framework implementan tuplas con más de 7 elementos anidando una tupla en Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Rest, item8 es un elemento de una tupla anidada.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con siete elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

T7

El tipo del séptimo elemento.

Parámetros

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

La tupla de siete elementos que se deconstruirá en siete variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método devuelve, contiene el valor del sexto elemento.

item7: T7

Cuando este método devuelve , contiene el valor del séptimo elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con seis elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

T6

El tipo del sexto elemento.

Parámetros

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

La tupla de seis elementos que se deconstruirá en seis variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

item6: T6

Cuando este método devuelve, contiene el valor del sexto elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con cinco elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

T5

El tipo del quinto elemento.

Parámetros

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

La tupla de cinco elementos que se deconstruirá en cinco variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

item5: T5

Cuando este método devuelve , contiene el valor del quinto elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con cuatro elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

T4

El tipo del cuarto elemento.

Parámetros

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

La tupla de cuatro elementos que se deconstruirá en cuatro variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

item4: T4

Cuando este método devuelve , contiene el valor del cuarto elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con tres elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

T3

El tipo del tercer elemento.

Parámetros

value: Tuple<T1,T2,T3>

La tupla de tres elementos que se deconstruirá en tres variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

item3: T3

Cuando este método devuelve , contiene el valor del tercer elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con dos elementos en variables independientes.

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)

Parámetros de tipo

T1

El tipo del primer elemento.

T2

El tipo del segundo elemento.

Parámetros

value: Tuple<T1,T2>

La tupla de dos elementos que se deconstruirá en dos variables independientes.

item1: T1

Cuando este método devuelve , contiene el valor del primer elemento.

item2: T2

Cuando este método devuelve , contiene el valor del segundo elemento.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a

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

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Source:: TupleExtensions.cs

Deconstruye una tupla con un elemento en una variable independiente.

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)

Parámetros de tipo

T1

El tipo del elemento único.

Parámetros

value: Tuple<T1>

La tupla de un elemento que se deconstruirá en una variable independiente.

item1: T1

Cuando este método devuelve , contiene el valor del elemento único.

Comentarios

Este método se implementa principalmente para admitir las características del lenguaje de tupla en C#.

Consulte también

Se aplica a