Tipo anónimo de C#

　En C#, los tipos anónimos son tipos (clases) sin nombre, que solo pueden contener propiedades públicas de solo lectura. No pueden contener otros miembros, como campos, métodos, eventos, etc.

El siguiente ejemplo muestra cómo crear una variable de tipo anónimo student que contiene tres propiedades: Id, FirstName y LastName.

var　student　=　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　};

Las propiedades de los tipos anónimos son de solo lectura, no se puede usar null, funciones anónimas o tipos de punteros para inicializarlas. Se puede usar la notación de punto (.) para acceder a estas propiedades, como si fueran propiedades de un objeto. Sin embargo, no se puede cambiar el valor de las propiedades, ya que son de solo lectura.

var　student　=　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　};
Console.WriteLine(student.Id);　//Salida1
Console.WriteLine(student.FirstName);　//Salida: James
Console.WriteLine(student.LastName);　//Salida: Bond
student.Id　=　2;//Error: no se puede cambiar el valor
student.FirstName　=　"Steve";//Error: no se puede cambiar el valor

Las propiedades de los tipos anónimos pueden incluir otro tipo anónimo.

var　student　=　new　{　
　　　　　　　　　　　　　　　　　　　　Id　=　1,　
　　　　　　　　　　　　　　　　　　　　FirstName　=　"James",　
　　　　　　　　　　　　　　　　　　　　LastName　=　"Bond",
　　　　　　　　　　　　　　　　　　　　Address　=　new　{　Id　=　1,　City　=　"London",　Country　=　"UK"　}
　　　　　　　　　　　　　　　　};

También puede crear una matriz de tipos anónimos.

var　students　=　new[]　{
　　　　　　　　　　　　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　},
　　　　　　　　　　　　new　{　Id　=　2,　FirstName　=　"Steve",　LastName　=　"Jobs"　},
　　　　　　　　　　　　new　{　Id　=　3,　FirstName　=　"Bill",　LastName　=　"Gates"　}
　　　　};

Los tipos anónimos siempre son locales para los métodos que los definen. No se pueden devolver desde métodos. Sin embargo, los tipos anónimos pueden pasarse como parámetros de tipo de objeto a métodos, aunque no se recomienda hacerlo. Si es necesario pasárselos a otro método, utilice struct o class en lugar de tipo anónimo.

Generalmente, se crea un tipo anónimo utilizando la cláusula select de una consulta LINQ para devolver un subconjunto de propiedades de cada objeto de la colección.

class Program
{
　　　　static　void　Main(string[]　args)
　　　　{
　　　　　　　　IList<Student> studentList = new List<Student>() {　
　　　　　　　　　　　　new Student() { StudentID =　1, StudentName = "John", age =　18　},
　　　　　　　　　　　　new Student() { StudentID =　2, StudentName = "Steve", age =　21　},
　　　　　　　　　　　　new Student() { StudentID =　3, StudentName = "Bill", age =　18　},
　　　　　　　　　　　　new Student() { StudentID =　4, StudentName = "Ram", age =　20 },
　　　　　　　　　　　　new Student() { StudentID =　5, StudentName = "Ron", age =　21　}　
　　　　　　　　};
　　　　　　　　var students = from s in studentList
　　　　　　　　　　　　　　　　　　　　　　　select new { Id = s.StudentID, Name = s.StudentName };
　　　　　　　　foreach (var stud in students)
　　　　　　　　　　　　Console.WriteLine(stud.Id　+　"-"　+　stud.Name);
　　　　}
}
public class Student
{
　　　　public int StudentID { get; set; }
　　　　public string StudentName { get; set; }
　　　　public int age { get; set; }
}

1-John
2-Steve
3-Bill
4-Ram
5-Ron

En el ejemplo anterior, la cláusula select de la consulta LINQ solo selecciona las propiedades StudentID y StudentName y las renombra respectivamente como Id y Name. Por lo tanto, es muy útil para ahorrar memoria y código innecesario. La colección de resultados de la consulta solo contiene las propiedades StudentID y StudentName, como se muestra en la vista de depuración siguiente.

Visual Studio admite IntelliSense para tipos anónimos, como se muestra a continuación.

Dentro de todo, todos los tipos anónimos se derivan directamente de la clase System.Object. El compilador generará una clase con nombres generados automáticamente y aplicará el tipo adecuado a cada propiedad según la expresión de valor. A pesar de que su código no puede acceder a él. Puede ver el nombre utilizando el método GetType().

static　void　Main(string[]　args)
{　　　　
var　student　=　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　};　　　　
　　　　Console.WriteLine(student.GetType().ToString());
}