Tuple Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

Tuple.cs

Fornisce metodi statici per la creazione di oggetti tupla.

public ref class Tuple abstract sealed

public static class Tuple

type Tuple = class

Public Class Tuple

Ereditarietà

Object

Tuple

Esempio

Nell'esempio seguente viene creata una tupla a 8 (ottuple) che contiene numeri primi minori di 20.

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

Commenti

Una tupla è una struttura dati con un numero e una sequenza specificati di elementi Un esempio di tupla è una struttura di dati costituita da tre elementi, nota come tupla con 3 elementi o terna, utilizzata per archiviare un identificatore come il nome di una persona nel primo elemento, un anno nel secondo elemento e il reddito della persona relativo a tale anno nel terzo elemento. .NET Framework supporta direttamente le tuple contenenti da uno a sette elementi. È inoltre possibile creare tuple di otto o più elementi annidando gli oggetti tupla nella proprietà Rest di un oggetto Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Le tuple sono comunemente usate in quattro modi:

• 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 un facile accesso e la manipolazione di un set di dati.

• Per restituire più valori da un metodo senza utilizzare i parametri out in C# o i parametri ByRef in Visual Basic).

• Per passare più valori a un metodo tramite un singolo parametro. Ad esempio, il metodo Thread.Start(Object) dispone di un solo parametro che consente di fornire un unico valore al metodo eseguito dal thread al momento dell'avvio. Se si specifica un Tuple<T1,T2,T3> oggetto come argomento del metodo, è possibile specificare la routine di avvio del thread con tre elementi di dati.

La classe Tuple non rappresenta una tupla. Si tratta invece di una classe che fornisce metodi statici per la creazione di istanze dei tipi di tupla supportati da .NET Framework. Tale classe fornisce i metodi di supporto che è possibile chiamare per creare istanze di oggetti tupla senza dover specificare in modo esplicito il tipo di ogni componente della tupla.

Sebbene sia possibile creare un'istanza di una classe tupla chiamando il relativo costruttore, il codice che esegue tale operazione può essere complesso. Nell'esempio seguente viene utilizzato il costruttore della classe per la creazione di una tupla con sette elementi o settupla contenente i dati della popolazione di New York per ogni censimento dal 1950 al 2000.

// Create a 7-tuple.
var population = new Tuple<string, int, int, int, int, int, int>(
                           "New York", 7891957, 7781984, 
                           7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple<string, int, int, int, int, int, int>(
                            "New York", 7891957, 7781984, 
                            7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population As New Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer) _
                           ("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

La creazione dello stesso oggetto tupla utilizzando un metodo di supporto è più semplice, come illustrato nell'esempio seguente.

// Create a 7-tuple.
var population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278);
// Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7);
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

// Create a 7-tuple.
let population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// Display the first and last elements.
printfn $"Population of {population.Item1} in 2000: {population.Item7:N0}"
// The example displays the following output:
//       Population of New York in 2000: 8,008,278

' Create a 7-tuple.
Dim population = Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' Display the first and last elements.
Console.WriteLine("Population of {0} in 2000: {1:N0}",
                  population.Item1, population.Item7)
' The example displays the following output:
'        Population of New York in 2000: 8,008,278

I metodi di supporto Create supportano direttamente la creazione di oggetti tupla che includono da uno a otto componenti i (da singleton a ottuple). Anche se non esiste alcun limite pratico al numero di componenti che una tupla può avere, i metodi helper non sono disponibili per creare una tupla con nove o più componenti. Per creare tale tupla, è necessario chiamare il costruttore Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.

Nota

Per ulteriori informazioni ed esempi che utilizzano le tuple, vedere la documentazione relativa ai tipi di tupla individuali in .NET Framework. Tali tipi di tupla sono elencati nella sezione Vedere anche alla fine di questo argomento.

Metodi

Create<T1,T2,T3,T4,T5,T6,T7,T8>(T1, T2, T3, T4, T5, T6, T7, T8)	Crea una nuova tupla con 8 elementi, ovvero un'ottupla.
Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7)	Crea una nuova tupla con 7 elementi, ovvero una settupla.
Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Crea una nuova tupla con 6 elementi, ovvero una sestupla.
Create<T1,T2,T3,T4,T5>(T1, T2, T3, T4, T5)	Crea una nuova tupla con 5 elementi, ovvero una quintupla.
Create<T1,T2,T3,T4>(T1, T2, T3, T4)	Crea una nuova tupla con 4 elementi, ovvero una quadrupla.
Create<T1,T2,T3>(T1, T2, T3)	Crea una nuova tupla con 3 elementi, ovvero una terna.
Create<T1,T2>(T1, T2)	Crea una nuova tupla con 2 elementi, ovvero una coppia.
Create<T1>(T1)	Crea una nuova tupla con un solo elemento, ovvero un singleton.

Vedi anche

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