Indtil nu har jeg skrevet lidt om Object og Collection Initializers, Automatic properties samt extension methods.

Type inferens er en af de ting egenskaber i et programmeringssprog som gør, at man ikke behøver være eksplicit omkring definitionen af typer, da typen kan udledes.

int a = 42;
var b = a;
b++;

Når var keywordet bruges, udleder kompileren typen af variablen fra initialiseringen af variablen eller objektet. I ovenstående er b altså en int fordi typen kan henføres til a er. Det vigtigste er, at typestærkheden bevares. IL koden er identisk uanset om b var deklareret som int eller med brug af var.

Ulempen ved type inferens er selvfølgelig at det kan misbruges - hvorfor bekymre sig om typer, når man bare kan deklarere dem som var? For det første kan det blive svært at læse, og for det andet, så er der tale om lokal type inferens. Kompileren kan kun udlede typer indenfor samme scope. Grunden til at vi skal bruge type inferens skyldes, at det er den eneste måde at implementere anonyme typer på.

Anonyme typer er også en af de interessante ting i C# 3.0. I C# 3.0 specifikationen står der:

"C# 3.0 permits the new operator to be used with an anonymous object initializer to create an object of an anonymous type."

Anonyme typer giver god mening, når man runtime gerne vil lave en ny type inden for samme scope. Ofte populerer man dataklasser med data fra en backend. Dataklasserne har man hidtil været nødsaget til at skulle definere eksplicit for at arbejde med dem. Det behøver man ikke længere, når man altså arbejder inden for samme scope.

Der er flere af de nye features i spil i ovenstående. Object initializers som medfører en fleksibel måde kan instantiere objekter, og lokal type inferens. Desuden bruges new keywordet, for at specificere at der skal generes en nye (anonym) klasse.

Hvis vi arbejder lidt videre med ovenstående, så kan vi lege lidt object initializers, lokal type inferens og anonyme typer. I følgende eksempel bruger jeg developer klassen fra tidligere blogpost om extension methods:

Developer d0 = new Developer { FirstName = "Anders" };
var d1 = new Developer { FirstName = "Bob" };
var d2 = new { FirstName = "Christian" };
var d3 = new { d1.FirstName };
var d4 = new { Dev = d1 };
Console.WriteLine("d0 type" + d0.GetType());
Console.WriteLine("d1 type" + d1.GetType());
Console.WriteLine("d2 type" + d2.GetType());
Console.WriteLine("d3 type" + d4.GetType());
Console.WriteLine("d4 type" + d4.GetType());

Resultatet bliver:

d0 typeof ConsoleApplication1.Developer
d1 typeof ConsoleApplication1.Developer
d2 typeof <>f__AnonymousType1`1[System.String]
d3 typeof <>f__AnonymousType1`1[System.String]
d4 typeof <>f__AnonymousType2`1[ConsoleApplication1.Developer]

Der bliver altså oprettet 2 typer anonyme typer: d2 og d3 er af same type, og en type af d4. Det afledes at d2 og d3 indeholder strings, object initializer er brugt ved alle initialiseringer.

Jeg faldt over denne Hands on lab, hvor du kommer i gennem de nye sprogfeatures i C# 3.0. Den kan man godt bruge lidt tid på hvis man vil hele vejen rundt C# 3.0.