Compartir a través de

Tipos anónimos (Guía de programación de C#)

Los tipos anónimos proporcionan una manera cómoda de encapsular un conjunto de propiedades de solo lectura en un solo objeto sin definir primero un tipo con nombre. El compilador genera un nombre de tipo en tiempo de compilación al que no se puede acceder en el código fuente. El compilador deduce el tipo de cada propiedad.

Cree tipos anónimos mediante el new operador junto con un inicializador de objeto. En el ejemplo siguiente se muestra un tipo anónimo que se inicializa con dos propiedades y NameAge:

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

Nombres de propiedad inferidos

Puede especificar los nombres de propiedad explícitamente mediante la Name = value sintaxis . Al inicializar un tipo anónimo con una expresión de acceso de miembro o variable, el compilador deduce el nombre de propiedad de esa expresión:

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

En el ejemplo anterior, el compilador deduce productName y price como los nombres de propiedad de los nombres de variable usados en el inicializador.

Declarar tipos anónimos con var

Dado que el compilador genera el nombre de tipo y no puede acceder a él en el código fuente, debe usar var para declarar la variable local. No se puede especificar explícitamente el nombre de tipo:

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

Uso de tipos anónimos en consultas LINQ

Los tipos anónimos aparecen con más frecuencia en la select cláusula de una expresión de consulta, donde proyectan un subconjunto de propiedades de cada elemento de origen:

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.

Igualdad

Dos instancias de tipo anónimo que tienen los mismos nombres de propiedad y tipos en el mismo orden comparten el mismo tipo generado por el compilador. El compilador invalida Equals y GetHashCode para que la igualdad compare los valores de propiedad en lugar de la identidad de referencia:

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 anidados

Los tipos anónimos pueden contener otros tipos anónimos como valores de propiedad:

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

Los tipos anónimos tienen las siguientes características:

Limitaciones

Los tipos anónimos tienen varias limitaciones:

  • No se pueden usar como tipos de valor devuelto de método, parámetros de método o tipos de campo porque no se puede asignar un nombre al tipo.
  • Se limitan al ámbito del método donde se declaran.
  • No se pueden agregar métodos, eventos ni operadores personalizados.
  • Las propiedades siempre son de solo lectura; Los tipos anónimos no admiten propiedades mutables.

Cuándo usar tuplas en su lugar

Para la mayoría del código nuevo, considere la posibilidad de usar tuplas en lugar de tipos anónimos. Como tipos de valor, las tuplas proporcionan un mejor rendimiento. También proporcionan compatibilidad con deconstrucción y sintaxis más flexible. Los tipos anónimos siguen siendo la mejor opción cuando se necesita compatibilidad con árboles de expresiones o semántica de tipo de referencia. Para obtener una comparación detallada, consulte Elección entre tipos anónimos y de tupla.

Consulte también

  • Last updated on