C# 匿名类型

　In C# sind anonyme Typen keine typisierten Typen (Klassen), deren Name nur öffentliche schreibgeschützte Attribute enthalten kann. Sie können keine anderen Mitglieder wie Felder, Methoden, Ereignisse usw. enthalten.

Das folgende Beispiel zeigt, wie eine anonyme Typenvariable student mit den drei Attributen Id, FirstName und LastName erstellt wird.

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

Die Attribute von anonymen Typen sind schreibgeschützt und können nicht mit null, anonymen Funktionen oder Zeigertypen initialisiert werden. Diese Attribute können mit dem Punkt-Notation (.) wie bei Objektattributen erreicht werden. Sie können jedoch den Wert der Attribute nicht ändern, da sie schreibgeschützt sind.

var　student　=　new　{　Id　=　1,　FirstName　=　"James",　LastName　=　"Bond"　};
Console.WriteLine(student.Id);　//Ausgabe1
Console.WriteLine(student.FirstName);　//Ausgabe: James
Console.WriteLine(student.LastName);　//Ausgabe: Bond
student.Id =　2;//Fehler: Wert kann nicht geändert werden
student.FirstName = "Steve";//Fehler: Wert kann nicht geändert werden

Die Attribute von anonymen Typen können auch einen anderen anonymen Typ umfassen.

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

Sie können auch ein Array von anonymen Typen erstellen.

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

Anonyme Typen sind für die Methoden, die sie definieren, immer lokal. Sie können nicht von Methoden zurückgegeben werden. Anonyme Typen können jedoch als Objekttypparameter an Methoden übergeben werden, dies wird jedoch nicht empfohlen. Wenn Sie sie an eine andere Methode übergeben müssen, verwenden Sie stattdessen struct oder class anstatt anonymer Typen.

In der Regel werden anonyme Typen durch den Select-Ausdruck einer LINQ-Abfrage erstellt, um eine Teilmenge der Eigenschaften jedes Objekts aus der Sammlung zurückzugeben.

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

Im obigen Beispiel wählt der select-Ausdruck im LINQ-Abfrage nur die Eigenschaften StudentID und StudentName aus und benennt sie entsprechend in Id und Name um. Daher ist es sehr nützlich, um Speicher und unnötigen Code zu sparen. Die Ergebnissammlung enthält nur die Eigenschaften StudentID und StudentName, wie im folgenden Debug-View gezeigt.

Visual Studio unterstützt IntelliSense für anonyme Typen, wie folgt.

Innerhalb, alle anonymen Typen abgeleitet direkt von der Klasse System.Object. Der Compiler generiert eine Klasse mit einigen automatisch generierten Namen und wendet entsprechend der Wertausdrücke den angemessenen Typ auf jede Eigenschaft an. Obwohl Ihr Code darauf nicht zugreifen kann. Mit der Methode GetType() kann der Name angezeigt werden.

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