Tuple di C#

La classe Tuple<T> è stata introdotta nel .NET Framework 4.0. Un tuple è una struttura dati che contiene una sequenza di elementi di diversi tipi di dati. Può essere utilizzato quando si desidera una struttura dati per salvare oggetti con attributi, ma non si desidera creare un tipo separato per loro.

Sintassi:

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

Esempio seguente crea un tuple contenente tre elementi:

Tuple<int, string, string> person = new Tuple<int, string, string>(1, "Steve", "Jobs");

Nell'esempio precedente, abbiamo creato un Tuple che contiene un'istanza del record di una persona. Assegniamo un tipo a ciascun elemento e passiamo i valori al costruttore. Specificare il tipo di ciascun elemento è complicato. C# ha introdotto una classe ausiliaria statica Tuple, che restituisce un'istanza di Tuple <T> senza dover specificare il tipo di ciascun elemento, come mostrato di seguito.

var person = Tuple.Create(1, "Steve", "Jobs");

Un tuple può contenere al massimo otto elementi. Quando si tenta di includere otto o più elementi, viene generato un errore di compilazione.

var numbers = Tuple.Create(1, 2, 3, 4, 5, 6, 7, 8);

Accedi agli elementi del tuple

Gli elementi del tuple possono essere acceduti tramite l'attributo Item < elementnumber >, ad esempio Item1, Item2, Item3, ecc., fino a Item7. L'attributo Item1 restituisce il primo elemento, Item2 il secondo elemento, e così via. L'ultimo elemento (ottavo elemento) viene restituito utilizzando l'attributo Rest.

var person = Tuple.Create(1, "Steve", "Jobs");
person.Item1; // restituisce 1
person.Item2; // restituisce "Steve"
person.Item3; // restituisce "Jobs"
var numbers = Tuple.Create("One", 2, 3, "Four", 5, "Six", 7, 8);
numbers.Item1; // restituisce "One"
numbers.Item2; // Restituisce 2
numbers.Item3; // restituisce 3
numbers.Item4; // restituisce "Four"
numbers.Item5; // restituisce 5
numbers.Item6; // restituisce "Six"
numbers.Item7; // restituisce 7
numbers.Rest; // restituisce (8)
numbers.Rest.Item1; // restituisce 8

Di solito, la posizione ottava è utilizzata per i tuple annidati, è possibile accedere a questa posizione utilizzando l'attributo Rest.

Tuple annidato

Se si desidera includere otto o più elementi in un tuple, è possibile farlo utilizzando un altro oggetto tuple come ottavo elemento. È possibile accedere all'ultimo tuple annidato utilizzando l'attributo Rest. Per accedere agli elementi del tuple annidato, utilizzare l'attributo Rest.Item1.Item<elementNumber>.

var numbers = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9, 10, 11, 12, 13));
numbers.Item1; // Restituisce 1
numbers.Item7; // restituisce 7
numbers.Rest.Item1; // restituisce (8,9,10,11,12,13)
numbers.Rest.Item1.Item1; // Restituisce 8
numbers.Rest.Item1.Item2; // Restituisce 9

È possibile includere oggetti di tuple annidate in qualsiasi posizione della sequenza. Tuttavia, si consiglia di posizionare le tuple annidate alla fine della sequenza per poter accedere all'attributo Rest.

var numbers = Tuple.Create(1, 2, Tuple.Create(3, 4, 5, 6, 7, 8), 9, 10, 11, 12, 13);
numbers.Item1; // Restituisce 1
numbers.Item2; // Restituisce 2
numbers.Item3; // Restituisce (3, 4, 5, 6, 7, 8)
numbers.Item3.Item1; // Restituisce 3
numbers.Item4; // Restituisce 9
numbers.Rest.Item1; // Restituisce 13

Tuple come parametro del metodo

Un metodo può passare una tupla come parametro.

static void Main(string[] args)
{
	var person = Tuple.Create(1, "Steve", "Jobs");
　　　　DisplayTuple(person);
}
static void DisplayTuple(Tuple<int,string,string> person)
{
　　　　Console.WriteLine($"Id = { person.Item1}");
　　　　Console.WriteLine($"Nome = { person.Item2}");
　　　　Console.WriteLine($"Cognome = { person.Item3}");
}

Tuple come tipo di ritorno

Le tuple possono essere restituite da un metodo.

static void Main(string[] args)
{
	var person = GetPerson();
}
static Tuple<int, string, string> GetPerson()　
{
	return Tuple.Create(1, "Bill", "Gates");
}

Uso delle tuple

Le tuple possono essere utilizzate nelle seguenti circostanze:

1. Quando si desidera restituire più valori da un metodo senza utilizzare i parametri ref o out...

2. Quando si desidera passare più valori a un metodo tramite un singolo parametro...

3. Quando si desidera salvare temporaneamente le registrazioni del database o alcuni valori senza creare una classe separata...

Svantaggi di Tuple:

1. Tuple è un tipo di riferimento, non un tipo di valore. Viene allocato in heap e può causare operazioni CPU-intensive.

2. Tuple è limitata a otto elementi. Se è necessario memorizzare più elementi, è necessario utilizzare tuple annidate. Tuttavia, questo può causare ambiguità.

3. È possibile accedere agli elementi di Tuple utilizzando lo schema di nome Item <elementNumber>, il che non è molto ragionevole.
   

C#7 ha introdotto ValueTuple per superare le limitazioni di Tuple e rendere più facile l'uso di Tuple. Scopri di più nel prossimo capitolo.