Tuplas no C#
As tuplas no C# são uma estrutura de dados do tipo de referência que podem armazenar valores de diferentes tipos.
O que são tuplas?
As tuplas no C# são uma estrutura de dados do tipo de referência que podem armazenar valores de diferentes tipos.
A principal vantagem de uma tupla é permitir o armazenamento de múltiplos tipos, como por exemplo uma string e um int ao mesmo tempo.
Como o C# é uma linguagem fortemente tipada, esta possibilidade pode nos ajudar muito no dia-a-dia, evitando a criação de classes simples apenas para o transporte de dados.
var tupla = new Tuple<string, int>("Meu Texto", 7);
As tuplas podem conter vários elementos e o último será uma propriedade de extensão que retorna a referência da própria tupla.
Criando tuplas
A primeira forma que temos de criar tuplas é usando o new Tuple<T>, assim como fazemos normalmente com nossos objetos.
var tupla = new Tuple<string, int>("Meu Texto", 7);
A segunda forma que temos é utilizando o Tuple.Create<T>, que é basicamente um wrapper para o método anterior.
var tupla = Tuple.Create<string, int>("Meu Texto", 7);
Lendo uma tupla
Sempre que uma tupla é criada, o compilador adicionar automaticamente o nome ItemX aos seus valores, então no exemplo acima, teríamos Item1 sendo uma string com o texto Meu Texto e o Item2 sendo um int com o valor 7.
Podemos acessar este valor, utilizando o . após informar o nome da variável.
var tupla = Tuple.Create<string, int>("Meu Texto", 7);
Console.WriteLine(tupla.Item1); // Exibe "Meu Texto"
Console.WriteLine(tupla.Item2); // Exibe 7
Este padrão é mantido por toda tupla, então caso você tenha uma tupla com 20 elementos, teria a variável tupla.Item20.
Inferindo os tipos
Particularmente não gosto de utilizar new Tuple<T> nem Tuple<T>.Create() por alguns motivos, e o primeiro deles é que uma tupla pode ser inferida de forma muito simples no C#.
(string, int) tupla = ("Meu Texto", 7);
Console.WriteLine(tupla.Item1); // Exibe "Meu Texto"
Console.WriteLine(tupla.Item2); // Exibe 7
Apenas colocando (string, int) podemos criar uma tupla com estes valores, tornando o código bem menos verboso.
O mesmo vale para o uso do var na criação da variável. Dado um conjunto de valores, o C# já entende que isto é uma tupla.
var tupla = ("Meu Texto", 7);
Console.WriteLine(tupla.Item1); // Exibe "Meu Texto"
Console.WriteLine(tupla.Item2); // Exibe 7
Nomeando os itens
O segundo motivo pelo qual prefiro inferir os tipos ao declarar new Tuple <T> ou Tuple<T>.Create é a possibilidade de nomear os itens.
Como vimos anteriormente, ao criar uma tupla, podemos ter N elementos e posteriormente o compilador os nomeia automaticamente para ItemX.
Porém, quando inferimos o tipo, podemos nomear os itens individualmente, como mostrado abaixo.
(string Primeiro, int Segundo) tupla = ("Meu Texto", 7);
Console.WriteLine(tupla.Item1); // Exibe "Meu Texto"
Console.WriteLine(tupla.Item2); // Exibe 7
Console.WriteLine(tupla.Primeiro); // Exibe "Meu Texto"
Console.WriteLine(tupla.Segundo); // Exibe 7
Note que no exemplo acima ainda temos o Item1 e Item2, eles não são descartados, porém, temos os itens Primeiro e Segundo, conforme nomeamos previamente na criação da tupla.
Listas em tuplas
Podemos utilizar listas como itens das tuplas, tanto List quanto Array. Na verdade podemos utilizar qualquer objeto aqui.
var tupla = (4.5, new List<string>());
tupla.Item2.Add("Meu Texto");
tupla.Item2.Add("Mais um");
foreach (var item in tupla.Item2)
Console.WriteLine(item);
No exemplo acima, criamos uma tupla que tem um item double e um List<string>. Em seguida, populamos a lista com dois elementos e exibimos eles na tela.
Tuplas em métodos
As tuplas podem ser amplamente usadas, inclusive como entrada e saída de funções caso haja necessidade de múltiplos parâmetros em uma única variável.
Parâmetros
No exemplo abaixo temos uma função que imprime o nome na tela. Este é representado pelo parâmetro name, cujo tipo é uma Tuple<string, string>, neste caso representado pelo tipo inferido (string FirstName, string LastName).
SayMyName(("André", "Baltieri"));
void SayMyName((string FirstName, string LastName) name)
=> Console.WriteLine($"{name.FirstName} {name.LastName}");
Retorno
Outro uso bem comum das tuplas é no retorno de um método, principalmente quando não queremos criar uma classe apenas para retornar mais de um valor.
var name = WhatsMyName("André", "Baltieri");
Console.WriteLine(name.FirstName); // Imprime André
Console.WriteLine(name.LastName); // Imprime Baltieri
(string FirstName, string LastName) WhatsMyName(string firstName, string lastName)
=> (firstName, lastName);
No exemplo acima, temos um método chamado WhatsMyName que recebe duas strings e retorna uma tupla.
Note que após a chamada do método, armazenamos a tupla em uma variável chamada name e a partir daí podemos chamar seus valores independentes como name.FirstName e name.LastName.
ValueTuple
As tuplas são tipos de referência, o que significa que são armazenados no heap e imutáveis. Quaisquer alterações neles, geram um novo objeto.
Caso precise, temos também o ValueTuple que define uma tupla mas como tipo de valor, alocado no stack como os outros tipos buil-in.
var tuple = new ValueTuple<string, int>("Meu Texto", 7);
Conclusão
As tuplas são um tipo de referência (Ou valor no caso dos ValueTuple) que nos oferecem uma flexibilidade enorme no C#, permitindo criar variáveis que alocam diferentes tipos de dados.
