C# Language
Anonyme Typen

Anonymen Typ erstellen

Da anonyme Typen nicht benannt werden, müssen die Variablen dieser Typen implizit typisiert werden ( var ).

var anon = new { Foo = 1, Bar = 2 };
// anon.Foo == 1
// anon.Bar == 2

Wenn die Mitgliedsnamen nicht angegeben sind, werden sie auf den Namen der Eigenschaft / Variablen gesetzt, mit der das Objekt initialisiert wird.

int foo = 1;
int bar = 2;
var anon2 = new { foo, bar };
// anon2.foo == 1
// anon2.bar == 2

Beachten Sie, dass Namen nur ausgelassen werden können, wenn der Ausdruck in der anonymen Typdeklaration ein einfacher Eigenschaftszugriff ist. Für Methodenaufrufe oder komplexere Ausdrücke muss ein Eigenschaftsname angegeben werden.

string foo = "some string";
var anon3 = new { foo.Length };
// anon3.Length == 11
var anon4 = new { foo.Length <= 10 ? "short string" : "long string" };
// compiler error - Invalid anonymous type member declarator.
var anon5 = new { Description = foo.Length <= 10 ? "short string" : "long string" };
// OK

Anonym vs. Dynamik

Mit anonymen Typen können Objekte erstellt werden, ohne dass sie vorab explizit definiert werden müssen, während die statische Typprüfung beibehalten wird.

var anon = new { Value = 1 };
Console.WriteLine(anon.Id); // compile time error

Im Gegensatz dazu hat dynamic eine dynamische Typprüfung und entscheidet sich für Laufzeitfehler anstelle von Kompilierzeitfehlern.

dynamic val = "foo";
Console.WriteLine(val.Id); // compiles, but throws runtime error

Generische Methoden mit anonymen Typen

Generische Methoden ermöglichen die Verwendung anonymer Typen durch Typinferenz.

void Log<T>(T obj) {
    // ...
}
Log(new { Value = 10 });

Dies bedeutet, dass LINQ-Ausdrücke mit anonymen Typen verwendet werden können:

var products = new[] {
    new { Amount = 10, Id = 0 },
    new { Amount = 20, Id = 1 },
    new { Amount = 15, Id = 2 }
};
var idsByAmount = products.OrderBy(x => x.Amount).Select(x => x.Id);
// idsByAmount: 0, 2, 1

Instanziieren generischer Typen mit anonymen Typen

Die Verwendung von generischen Konstruktoren erfordert die Benennung der anonymen Typen, was nicht möglich ist. Alternativ können generische Verfahren verwendet werden, um das Auftreten von Typinferenz zu ermöglichen.

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 5, Bar = 10 };
List<T> CreateList<T>(params T[] items) {
    return new List<T>(items);
}

var list1 = CreateList(anon, anon2);

Im Falle von List<T> können implizit typisierte Arrays durch die ToList LINQ-Methode in eine List<T> ToList werden:

var list2 = new[] {anon, anon2}.ToList();

Anonyme Typgleichheit

Die Gleichheit eines anonymen Typs wird durch die Instanzmethode Equals . Zwei Objekte sind gleich, wenn sie den gleichen Typ und gleiche Werte haben (durch a.Prop.Equals(b.Prop) ) für jede Eigenschaft.

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 1, Bar = 2 };
var anon3 = new { Foo = 5, Bar = 10 };
var anon3 = new { Foo = 5, Bar = 10 };
var anon4 = new { Bar = 2, Foo = 1 };
// anon.Equals(anon2) == true
// anon.Equals(anon3) == false
// anon.Equals(anon4) == false (anon and anon4 have different types, see below)

Zwei anonyme Typen werden nur dann als identisch angesehen, wenn ihre Eigenschaften denselben Namen und Typ haben und in derselben Reihenfolge angezeigt werden.

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 7, Bar = 1 };
var anon3 = new { Bar = 1, Foo = 3 };
var anon4 = new { Fa = 1, Bar = 2 };
// anon and anon2 have the same type
// anon and anon3 have diferent types (Bar and Foo appear in different orders)
// anon and anon4 have different types (property names are different)

Implizit typisierte Arrays

Arrays von anonymen Typen können mit impliziter Typisierung erstellt werden.

var arr = new[] {
    new { Id = 0 },
    new { Id = 1 }
};