Anonymous Type

Objecten worden gevormd door klassen. Een klasse wordt gedeclareerd met een aantal velden, eigenschappen en/of methoden. Dan kan een instance van deze klasse gemaakt worden en dat noemt men een object. Met de invoering van anonymous types is het niet nodig eerst een klasse te declareren alvorens een object te creëren. Geen paniek, klassen zijn nog niet afgeschreven, want anonymous types (of objecten) komen met verschillende beperkingen, maar in sommige omstandigheden zijn ze zeer nuttig!

Een anonymous type wordt geïnitialiseerd met de new operator in combinatie met een object initialisatie. Tot zover lijkt het erg op het instantiëren van een klasse maar de naam van de klasse wordt weggelaten. Omdat er geen klasse vermeld wordt achter het object, moet het var sleutelwoord gebruikt worden wanneer naar het object verwezen wordt. Dit lijkt ingewikkeld maar een voorbeeld laat zien dat het wel meevalt:

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

Zo, klaar. We hebben nu een object met informatie (naam en leeftijd) over een gebruiker. Anonymour types zijn erg handig in tal van situaties, vooral als je iets snel moet retourneren dat complexer is dan alleen maar een string of een getal. Anonymous types stellen in staat vliegensvlug properties te maken, zonder dat je eerst een class hoeft te declareren en daarna die class gaat veranderen als je dat nodig hebt. Maar zoals gezegd, er zijn diverse beperkingen die je moet kennen als je er over denkt om liever een anonymous type te gaan gebruiken dan een class te moeten definiëren:

• In tegenstelling tot een echte class, kan een anonymous type geen velden hebben of methods, alleen maar properties
• Als het object eenmaal geïnitialiseerd is, kun je er geen nieuwe properties meer aan toevoegen
• Properties zijn readonly. Zodra het object is geïnitialiseerd kun je de waarden niet meer veranderen

Maar dat gezegd hebbende, zijn anonymous types nog altijd ontzettend praktisch voor een hele reeks taken. Een gebruikelijk scenario is wanneer je een complex object hebt (van een gedefinieerde class) en je moet dat vereenvoudigen, bv omdat je het object zo klein mogelijk wilt hebben om het naar een browser te sturen, of omdat het complete object informatie bevat die je niet aan een gebruiker wilt laten zien. Anonymous types zijn hier uitstekend geschikt voor, zoals blijkt uit het volgende voorbeeld:

using System;
using System.IO;

namespace AnonymousTypes
{
    class Program
    {
    static void Main(string[] args)
    {
        string pathOfExe = System.Reflection.Assembly.GetEntryAssembly().Location;
        FileInfo fileInfo = new FileInfo(pathOfExe);
        var simpleFileInfo = new
        {
        Filename = fileInfo.Name,
        FileSize = fileInfo.Length
        };
        Console.WriteLine("File name: " + simpleFileInfo.Filename + ". Size: " + simpleFileInfo.FileSize + " bytes");
    }
    }
}

Op de eerste regel verkrijgen we de bestandsnaam van het huidige bestand, dus van onze eigen applicatie. Deze gebruiken we om een instantie te creëren van de FileInfo klasse, die VEEL informatie bevat over dit specifiek bestand. Al deze informatie hebben we niet nodig. Dus maken we er een vereenvoudigde versie van met een anonymous type, gebruik makend van de originele FileInfo instantie. Op de laatste regel gebruiken we die informatie om wat uitvoer te verkrijgen.

Elke eigenschap die gedefinieerd wordt in het anonymous type krijgt een naam (Filename en FileSize). Dit is logisch omdat we deze achteraf willen benaderen. Maar wanneer een object werkt met informatie van een bestaand object, kan de eigen naam weggelaten worden en de compiler alleen de naam van de eigenschap laten gebruiken:

var simpleFileInfo = new
{
    fileInfo.Name,
    fileInfo.Length
};

Nu hebben we twee eigenschappen met de namen Name en Length in plaats van Filename and FileSize. Dat is wel zo gemakkelijk, het gebruik van de dezelfde namen als in het oorspronkelijk object.

Samenvatting

Anonymous types laten toe snel een object te stantiëren met één of enkele eigenschappen. Deze eigenschappen zijn alleen lezen en er kunnen er later geen meer toegevoegd worden.