Tipos Anônimos do C#

　No C#, os tipos anônimos são tipos (classe) sem nome, que podem conter apenas propriedades públicas de leitura. Não podem conter outros membros, como campos, métodos, eventos, etc.

O exemplo a seguir demonstra como criar uma variável de tipo anônimo student que contém três propriedades: Id, FirstName e LastName.

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

As propriedades do tipo anônimo são de leitura apenas, não podem ser inicializadas com null, função anônima ou tipo de ponteiro. Pode usar a notação de ponto (.) para acessar essas propriedades, como as propriedades de um objeto. No entanto, você não pode alterar o valor das propriedades, porque são de leitura apenas.

var　student　=　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　};
Console.WriteLine(student.Id);　//Saída1
Console.WriteLine(student.FirstName);　//Saída: James
Console.WriteLine(student.LastName);　//Saída: Bond
student.Id =　2;//Erro: não é possível alterar o valor
student.FirstName = "Steve";//Erro: não é possível alterar o valor

As propriedades do tipo anônimo podem incluir outro tipo anônimo.

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

Você também pode criar uma matriz de tipos anônimos.

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

Os tipos anônimos são sempre locais para os métodos que os definem. Não podem ser retornados pelos métodos. No entanto, os tipos anônimos podem ser passados como parâmetros de tipo de objeto para métodos, mas não é recomendado fazer isso. Se precisar passar para outro método, use struct ou class em vez de tipo anônimo.

Normalmente, tipos anônimos são criados usando a cláusula select de consultas LINQ, para retornar um subconjunto de propriedades de cada objeto da coleção.

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

No exemplo acima, a cláusula select da consulta LINQ seleciona apenas as propriedades StudentID e StudentName e as renomeia respectivamente para Id e Name. Portanto, é útil para economizar memória e evitar código desnecessário. A coleção de resultados da consulta contém apenas as propriedades StudentID e StudentName, como mostrado na visão de depuração a seguir.

O Visual Studio suporta Intellisense para tipos anônimos, conforme mostrado a seguir.

Dentro, todos os tipos anônimos derivam diretamente da classe System.Object. O compilador gera uma classe com nomes automaticamente gerados e aplica o tipo apropriado a cada propriedade com base na expressão de valor. Embora seu código não possa acessá-lo. Você pode usar o método GetType() para ver o nome.

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