Compartilhar via

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

Os tipos anônimos proporcionam uma maneira conveniente de encapsular um conjunto de propriedades de leitura somente em um único objeto, sem a necessidade de definir inicialmente um tipo nomeado. O compilador gera um nome de tipo no tempo de compilação que você não pode acessar no código-fonte. O compilador infere o tipo de cada propriedade.

Crie tipos anônimos usando o new operador junto com um inicializador de objeto. O exemplo a seguir 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 propriedade inferidos

Você pode especificar nomes de propriedade explicitamente usando a Name = value sintaxe. Quando você inicializa um tipo anônimo com uma variável ou expressão de acesso de membro, o compilador infere o nome da propriedade 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 de propriedade dos nomes de variáveis usados no inicializador.

Declarar tipos anônimos com var

Como o compilador gera o nome do tipo e você não pode acessá-lo no código-fonte, você deve usar var para declarar a variável local. Você não pode especificar o nome do tipo explicitamente:

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

Usar tipos anônimos em consultas LINQ

Tipos anônimos aparecem com mais frequência na cláusula de uma expressão de consulta, em que projetam um subconjunto de propriedades de cada elemento de origem select :

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 de tipo anônimo que têm os mesmos nomes e tipos de propriedade na mesma ordem compartilham o mesmo tipo gerado pelo compilador. O compilador substitui Equals e GetHashCode , portanto, a igualdade compara valores de propriedade 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 propriedade:

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

Características

Tipos anônimos têm as seguintes características:

Limitações

Tipos anônimos têm várias limitações:

  • Você não pode usá-los como tipos de retorno de método, parâmetros de método ou tipos de campo porque você não pode nomear o tipo.
  • As variáveis têm como escopo o método onde são declaradas.
  • Você não pode adicionar métodos, eventos ou operadores personalizados.
  • As propriedades são sempre somente leitura; tipos anônimos não dão suporte a 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 fornecem melhor desempenho. Eles também fornecem suporte à desconstrução e sintaxe mais flexível. Os tipos anônimos continuam sendo a melhor opção quando você precisa de suporte de árvore de expressão ou semântica de tipo de referência. Para obter uma comparação detalhada, consulte Escolha entre tipos anônimos e tipos de tupla.

Consulte também

  • Last updated on