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

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Rappresenta una tupla di n valori, dove n è maggiore o uguale a 8.

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

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

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

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

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

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

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

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

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

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

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

Parametri di tipo

T1

Tipo del primo componente della tupla.

T2

Tipo del secondo componente della tupla.

T3

Tipo del terzo componente della tupla.

T4

Tipo del quarto componente della tupla.

T5

Tipo del quinto componente della tupla.

T6

Tipo del sesto componente della tupla.

T7

Tipo del settimo componente della tupla.

TRest

Qualsiasi oggetto Tuple generico che definisce i tipi dei componenti restanti della tupla.

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

Attributi: SerializableAttribute

Implementazioni: IStructuralComparable IStructuralEquatable IComparable ITuple

Commenti

Una tupla è una struttura di dati con un numero e una sequenza specifici di valori. La Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe rappresenta una tupla n con otto o più componenti.

È possibile creare un'istanza di un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> oggetto con esattamente otto componenti chiamando il metodo statico Tuple.Create . Nell'esempio seguente viene creata una tupla a 8 (ottuple) contenente numeri primi inferiori a 20. Si noti che usa l'inferenza dei tipi per determinare il tipo di ogni componente.

var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1);
// The example displays the following output:
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

open System

let primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
printfn $"Prime numbers less than 20: {primes.Item1}, {primes.Item2}, {primes.Item3}, {primes.Item4}, {primes.Item5}, {primes.Item6}, {primes.Item7}, and {primes.Rest.Item1}"
//    Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

Dim primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19)
Console.WriteLine("Prime numbers less than 20: " + 
                  "{0}, {1}, {2}, {3}, {4}, {5}, {6}, and {7}",
                  primes.Item1, primes.Item2, primes.Item3, 
                  primes.Item4, primes.Item5, primes.Item6,
                  primes.Item7, primes.Rest.Item1)
' The example displays the following output:
'     Prime numbers less than 20: 2, 3, 5, 7, 11, 13, 17, and 19

È anche possibile creare un'istanza di un oggetto n-tuple con otto o più componenti chiamando il Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> costruttore. Nell'esempio seguente viene usato il Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> costruttore per creare una tupla a 8 equivalente alla tupla creata nell'esempio precedente.

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

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

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

Nota

Per creare una tupla n con nove o più componenti, è necessario chiamare il Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> costruttore. I metodi static factory della Tuple classe non supportano la creazione di oggetti con più di Tuple otto componenti.

Per creare un'istanza di una tupla n con otto o più componenti con il Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> costruttore, specificare un oggetto generico Tuple come rest parametro per definire l'ottavo tramite ncomponenti della tupla. Annidando oggetti generici Tuple in questo modo, è possibile creare una tupla senza limitazioni pratiche sul numero dei relativi componenti.

Nell'esempio seguente viene creata una tupla da 17 tupla contenente i dati della popolazione per la città di Detroit, il Michigan, per ogni censimento nazionale compreso tra il 1860 e il 2000. Il primo componente della tupla è il nome della città. Il secondo componente è la data di inizio della serie di dati e il terzo componente è la popolazione alla data di inizio. Ogni componente successivo fornisce la popolazione a intervalli di decenni. La tupla da 17 viene creata annidando un Tuple<T1,T2,T3> oggetto all'interno di un Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> oggetto. Ovvero, l'oggetto Tuple<T1,T2,T3> viene fornito come valore del rest parametro nel costruttore di Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> classe. Questo Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> oggetto è, a sua volta, annidato in un oggetto esterno Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . Ovvero, l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> viene fornito come valore del rest parametro nel costruttore della classe dell'oggetto esterno Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .

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

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

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

È possibile recuperare il valore dei primi sette componenti della tupla usando le proprietà di sola Item1lettura , Item4 Item3 Item5 Item2 Item6e Item7 dell'istanza. Tutti i componenti aggiuntivi vengono annidati e possono essere recuperati dalla Rest proprietà. Nell'esempio precedente, le Item1 proprietà through Item7 recuperano il primo tramite il settimo componente della tupla. Gli ottavi e i quattordici componenti sono contenuti nella tupla annidata al secondo livello e sono rappresentati dalle Rest.Item1 proprietà tramite Rest.Item7 . I quindici a diciassette componenti sono contenuti nella tupla annidata al terzo livello e sono rappresentati dalle Rest.Rest.Item1 proprietà.Rest.Rest.Item3

Le tuple vengono comunemente usate in quattro modi diversi:

Per rappresentare un singolo set di dati. Ad esempio, una tupla può rappresentare un record di database e i relativi componenti possono rappresentare singoli campi del record.
Per consentire l'accesso semplice e la manipolazione di, un set di dati.
Per restituire più valori da un metodo senza l'uso di out parametri (in C#) o ByRef parametri (in Visual Basic). Ad esempio, l'esempio precedente restituisce le statistiche calcolate, insieme al nome della città, in un Tuple<T1,T2,T3,T4,T5,T6,T7> oggetto.
Per passare più valori a un metodo tramite un singolo parametro. Ad esempio, il Thread.Start(Object) metodo ha un singolo parametro che consente di specificare un valore al metodo eseguito dal thread all'avvio. Se si specifica un Tuple<T1,T2,T3,T4,T5,T6,T7> oggetto come argomento del metodo, è possibile fornire la routine di avvio del thread con sette elementi di dati.

Costruttori

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

Inizializza una nuova istanza della classe Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Proprietà

Item1	Ottiene il valore del primo componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item2	Ottiene il valore del secondo componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item3	Ottiene il valore del terzo componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item4	Ottiene il valore del quarto componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item5	Ottiene il valore del quinto componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item6	Ottiene il valore del sesto componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Item7	Ottiene il valore del settimo componente dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
Rest	Ottiene i componenti restanti dell'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.

Metodi

Equals(Object)	Restituisce un valore che indica se l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente è uguale a un oggetto specificato.
GetHashCode()	Calcola il codice hash per l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta il valore di questa istanza di Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)	Confronta l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente con un oggetto specificato e restituisce un intero che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato nell'ordinamento.
IStructuralComparable.CompareTo(Object, IComparer)	Confronta l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente con un oggetto specificato mediante un operatore di confronto specificato e restituisce un Integer che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato all'interno dell'ordinamento.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Restituisce un valore che indica se l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente è uguale a un oggetto specificato in base a un metodo di confronto specificato.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Calcola il codice hash per l'oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> corrente tramite un metodo di calcolo specificato.
ITuple.Item[Int32]	Ottiene il valore dell'elemento `Tuple` specificato.
ITuple.Length	Ottiene il numero di elementi in `Tuple`.

Si applica a

Condividi tramite