Het dynamic type

In C# 4.0 introduceerde Microsoft een nieuw type: de dynamic. Het is in feite een static type maar in tegenstelling tot de andere static types wordt het dynamic type niet gecontroleerd door de compiler. Dit geeft de voordelen van zowel de dynamisch getypeerde talen als de voordelen van de sterk getypeerde talen.

Declaratie gaat op dezelfde manier zoals bij elk ander type: gebruik het dynamic sleutelwoord op de plaats van het gegevenstype:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;

Nu zijn drie objecten: het eerste is op dit ogenblik niks (null), het tweede is een string en het derde is een integer. De interpreter beslist dat automatisch tijdens runtime afhankelijk van wat er toegekend wordt. Dat betekent ook dat de compiler niet controleert wat er gebeurt met deze variabelen zoals blijkt uit volgend voorbeeld:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;
Console.WriteLine(d2.Length);
Console.WriteLine(d3.Length);

Strings hebben een eigenschap 'length' om uit te maken hoe lang de string is. Een integer heeft dit niet. Hier wordt dit toegepast op beide variabelen en de compiler geeft geen foutmelding. Als deze variabelen gedeclareerd waren als string en integer zou de compiler wel een fout gemeld hebben. Maar omdat ze dynamic zijn worden ze gewoon gecompileerd en wordt het programma gewoon uitgevoerd. Maar zodra de interpreter de laatste lijn bereikt volgt er een exception omdat een eigenschap die niet bestaat, niet benaderd kan worden.

Dit laat ook het gevaar zien van 'dynamic types'. Je moet je steeds bewust zijn van wat je doet en er zeker van zijn dat je elke 'property' en het aanroepen van elke 'method' goed gespeld hebt, omdat de compiler jouw werk niet gaat dubbelchecken, waardoor hij toelaat dat je code produceert die steeds in de fout gaat.

Een dynamic objekt

Het dynamic sleutelwoord kan natuurlijk gebruikt worden voor meer complexe types dan integers en strings. Een goed voorbeeld is het gebruik van een anonymous object:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.Name + " is " + user.Age + " years old");

Dit laat toe van een object te creëren zonder eerst een klasse te definiëren. Het dynamic sleutelwoord is hier geschikt voor maar het var sleutelwoord kan in vele gevallen een betere keuze zijn.

't Is niet omdat een object dynamic is dat er later zo maar eigenschappen kunnen toegevoegd worden.

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
user.HomeTown = "New York";

Omdat er geen controle gebeurt tijdens het compileren, loopt deze code. De compiler valideert de HomeTown eigenschap niet, maar zodra de laatste lijn bereikt wordt, wordt een exception geworpen. Dat een type dynamic is wil niet zeggen dat er zo maar dynamisch nieuwe eigenschappen kunnen toegevoegd worden. Hiervoor kan het ExpandoObject gebruikt worden, dat in het volgend artikel besproken wordt.

Wijzigen van het type

Een variabele die dynamic gedeclareerd is, is helemaal niet zonder type. C# behandelt deze inwendig zoals het object dat er aan toegekend werd. In het eerste voorbeeld wordt een variabele als dynamic gedeclareerd. Dan wordt er een string en een integer aan toegekend en vervolgens worden de eigenschappen, die bij die types behoren, gebruikt. Het wijzigen van het type van een dynamic is eenvoudig: simpel er een andere waarde aan toekennen. Hier is een voorbeeld:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.GetType() + ": " + user.Name + " is " + user.Age + " years old");
user = "Jane Doe";
Console.WriteLine(user.GetType() + ": String.Length = " + user.Length);

Let op hoe de dynamic user variabele gebruikt wordt: eerst bevat ze een anonymous object en wordt er een eenvoudige string aan toegekend. Dit kan nagegaan worden met de GetType() methode die elk C# object heeft. In beide gevallen worden de eigenschappen benaderd die op dat ogenblik voor handen zijn (eerst Name/Age van het anonymous object en daarna de length eigenschap van string objecten).

Samenvatting

Het dynamic sleutelwoord laat toe van variabelen te gebruiken zonder vooraf een type vast te leggen. Zij hebben dan dezelfde eigenschappen als de gegevens die zij bevatten. Het is gemakkelijk een nieuwe variabele toe te kennen aan een dynamic variabele en als het type niet overeenkomt met het type dat de variabele al bevat, wordt het automatisch aangepast.

Dynamic variabelen worden niet gecontroleerd door de compiler zodat eigenschappen kunnen benaderd worden die al of niet aanwezig zijn. Dit maakt hen zeer flexibel maar maakt de toepassing gevoeliger voor fouten. Daarom moet hun gebruik beperkt worden tot die gevallen waarin het echt niet anders gaat. Voorbeelden waar dynamic types gebruikt worden is bij COM interoperatibiliteit en bij het werken met JSON en XML.