C# Language
Anonieme typen

Een anoniem type maken

Aangezien anonieme typen geen naam krijgen, moeten variabelen van die typen impliciet worden getypt ( var ).

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

Als de lidnamen niet zijn opgegeven, worden deze ingesteld op de naam van de eigenschap / variabele die wordt gebruikt om het object te initialiseren.

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

Merk op dat namen alleen kunnen worden weggelaten als de uitdrukking in de anonieme typeaangifte een eenvoudige eigenschapstoegang is; voor methodeaanroepen of complexere uitdrukkingen moet een eigenschapsnaam worden opgegeven.

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

Anoniem versus dynamisch

Met anonieme typen kunnen objecten worden gemaakt zonder dat ze vooraf expliciet hun typen moeten definiëren, met behoud van statische typecontrole.

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

Omgekeerd, dynamic heeft dynamische typecontrole, die kiest voor runtime-fouten in plaats van compilatie-fouten.

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

Generieke methoden met anonieme typen

Generieke methoden maken het gebruik van anonieme typen mogelijk door middel van type-inferentie.

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

Dit betekent dat LINQ-expressies kunnen worden gebruikt met anonieme typen:

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

Generieke typen instantiëren met anonieme typen

Het gebruik van generieke constructors vereist dat de anonieme typen worden genoemd, wat niet mogelijk is. Als alternatief kunnen generieke methoden worden gebruikt om type-inferentie mogelijk te maken.

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);

In het geval van List<T> kunnen impliciet getypte arrays worden omgezet in een List<T> via de ToList LINQ-methode:

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

Anonieme type gelijkheid

De gelijkheid van het anonieme type wordt gegeven door de Equals instantiemethode. Twee objecten zijn gelijk als ze hetzelfde type en dezelfde waarden hebben (via a.Prop.Equals(b.Prop) ) voor elke eigenschap.

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)

Twee anonieme typen worden als hetzelfde beschouwd als en alleen als hun eigenschappen dezelfde naam en hetzelfde type hebben en in dezelfde volgorde verschijnen.

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)

Impliciet getypte arrays

Arrays van anonieme typen kunnen worden gemaakt met impliciet typen.

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