Partilhar via

Tipos anónimos (Guia de Programação C#)

Tipos anónimos fornecem uma forma conveniente de encapsular um conjunto de propriedades de apenas leitura num único objeto sem definir primeiro um tipo nomeado. O compilador gera um nome de tipo em tempo de compilação ao qual não pode aceder no seu código-fonte. O compilador infere o tipo de cada propriedade.

Crie tipos anónimos usando o new operador juntamente com um inicializador de objetos. O exemplo seguinte mostra um tipo anónimo inicializado com duas propriedades, Name e Age:

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"{person.Name} is {person.Age} years old.");
// Output:
// Alice is 30 years old.

Nomes de propriedades inferidos

Podes especificar nomes de propriedades explicitamente usando a Name = value sintaxe. Quando inicializa um tipo anónimo com uma variável ou expressão de acesso a membros, o compilador infere o nome da propriedade a partir dessa expressão:

string productName = "Laptop";
decimal price = 999.99m;
var product = new { productName, price };
Console.WriteLine($"{product.productName}: {product.price:C}");
// Output:
// Laptop: $999.99

No exemplo anterior, o compilador infere productName e price como os nomes das propriedades a partir dos nomes das variáveis usadas no inicializador.

Declarar tipos anónimos com var

Como o compilador gera o nome do tipo e não consegues aceder a ele no código-fonte, tens de usar var para declarar a variável local. Não pode especificar explicitamente o nome do tipo:

// You must use var — you can't write a named type here.
var person = new { Name = "Alice", Age = 30 };

Use tipos anónimos em consultas LINQ

Tipos anónimos aparecem mais frequentemente na select cláusula de uma expressão de consulta, onde projetam um subconjunto de propriedades de cada elemento fonte:

var words = new[] { "apple", "blueberry", "cherry" };

var results = words.Select(w => new { Word = w, Length = w.Length });

foreach (var item in results)
{
    Console.WriteLine($"{item.Word} has {item.Length} letters.");
}
// Output:
// apple has 5 letters.
// blueberry has 9 letters.
// cherry has 6 letters.

Igualdade

Duas instâncias anónimas de tipos que têm os mesmos nomes de propriedades e tipos na mesma ordem partilham o mesmo tipo gerado pelo compilador. O compilador sobrescreve Equals e GetHashCode para que a igualdade compare os valores das propriedades em vez da identidade de referência:

var a = new { Name = "Alice", Age = 30 };
var b = new { Name = "Alice", Age = 30 };
var c = new { Name = "Bob", Age = 25 };

Console.WriteLine(a.Equals(b));  // True
Console.WriteLine(a.Equals(c));  // False

Tipos anónimos aninhados

Tipos anónimos podem conter outros tipos anónimos como valores de propriedades:

var order = new
{
    OrderId = 1,
    Customer = new { Name = "Alice", City = "Seattle" },
    Total = 150.00m
};
Console.WriteLine($"Order {order.OrderId} for {order.Customer.Name} in {order.Customer.City}");
// Output:
// Order 1 for Alice in Seattle

Caraterísticas

Os tipos anónimos têm as seguintes características:

  • O compilador gera-as como internal sealed class tipos que derivam de Object.
  • Todas as propriedades são public somente de leitura.
  • Tipos anónimos suportam with expressões para mutação não destrutiva.
  • O compilador gera substituições baseadas em valores Equals, GetHashCode e ToString.
  • Os tipos anónimos suportam árvores de expressão, enquanto as tuplas não.

Limitações

Os tipos anónimos têm várias limitações:

  • Não podes usá-los como tipos de retorno de métodos, parâmetros de método ou tipos de campo porque não podes nomear o tipo.
  • Estão ajustadas ao método onde as declaras.
  • Não podes adicionar métodos, eventos ou operadores personalizados.
  • As propriedades são sempre de apenas leitura; Os tipos anónimos não suportam propriedades mutáveis.

Quando usar tuplas em vez disso

Para a maioria dos novos códigos, considere usar tuplas em vez de tipos anónimos. Como tipos de valor, as tuplas oferecem melhor desempenho. Também fornecem apoio à desconstrução e uma sintaxe mais flexível. Os tipos anónimos continuam a ser a melhor escolha quando precisas de suporte para árvore de expressões ou semântica de tipos de referência. Para uma comparação detalhada, veja Escolher entre tipos anónimos e tipos de tuplas.

Consulte também

  • Last updated on