C# Language
Anonyma typer

Skapa en anonym typ

Eftersom anonyma typer inte heter, måste variabler av dessa typer implicit skrivas ( var ).

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

Om medlemsnamnen inte anges ställs de in på namnet på egenskapen / variabeln som används för att initialisera objektet.

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

Observera att namn endast kan utelämnas när uttrycket i den anonyma typdeklarationen är en enkel tillgång till egendom; För metodsamtal eller mer komplexa uttryck måste ett egendomsnamn anges.

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 dynamisk

Anonyma typer tillåter skapande av objekt utan att behöva definiera sina typer i förväg, samtidigt som statisk typkontroll upprätthålls.

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

Omvänt har dynamic dynamisk typkontroll och väljer runtime-fel istället för compile-time-fel.

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

Generiska metoder med anonyma typer

Generiska metoder tillåter användning av anonyma typer genom typinferens.

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

Detta betyder att LINQ-uttryck kan användas med anonyma typer:

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

Instantiera generiska typer med anonyma typer

Att använda generiska konstruktörer kräver att de anonyma typerna namnges, vilket inte är möjligt. Alternativt kan generiska metoder användas för att tillåta typinferens att inträffa.

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

När det gäller List<T> , kan implicit typmatade matriser konverteras till en List<T> genom ToList LINQ:

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

Anonym typjämlikhet

Anonym typjämlikhet ges med Equals instansmetoden. Två objekt är lika om de har samma typ och lika värden (genom a.Prop.Equals(b.Prop) ) för varje egenskap.

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)

Två anonyma typer betraktas som samma om och bara om deras egenskaper har samma namn och typ och visas i samma ordning.

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)

Implicit typmatade matriser

Matriser av anonyma typer kan skapas med implicit typning.

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