Er kunnen situaties optreden waarbij je als ontwikkelaar wél weet dat bepaalde methodes op een object bestaan, maar dat de compiler dat niet weet. Dit resulteert in vervelende compileerfouten. Deze situatie treedt op wanneer we een class willen initialiseren die uit een assembly komt waaraan nog niet gerefereerd wordt. Deze assembly wordt namelijk run-time geladen (bijvoorbeeld via de static methode Assembly.LoadFrom()).
Stel we hebben een assembly met de naam “DemoAssembly” waarin de volgende class is gedefinieerd:
class Persoon
{
public string Achternaam { get; set; }
public string Voornaam { get; set; }
public void StelJeVoor()
{
Console.WriteLine("Hallo, ik ben {0} {1}", Voornaam, Achternaam);
}
public Persoon(string achternaam, string voornaam = "Nn")
{
Achternaam = achternaam;
Voornaam = voornaam;
}
}
Om de StelJeVoor() methode uit deze class aan te roepen moet je de volgende stappen nemen.
1) De assembly inladen
Assembly asm = Assembly.LoadFrom("DemoAssembly");
2) Het gewenste type eruit halen
Type type = asm.GetType("Persoon");
3) Uit het type de gewenste methode halen
MethodInfo methodHandle = type.GetMethod("StelJeVoor");
4) Een instantie van dat type maken. (StelJeVoor() is een instantie methode)
object inst = Activator.CreateInstance(type, new object{"Janssen", "Karel"});
5) Tenslotte de methode uitvoeren (het object casten naar Persoon is niet mogelijk, omdat er niet gerefereerd wordt aan de assembly “DemoAsssembly”)
methodHandle.Invoke(inst, new object { });
Al met al een lastig gepeuter met strings en reflection.
In het .NET Framework 4.0 hebben we nu de beschikking over dynamische types. Hierdoor kunnen we het onbegrijpelijke stukje code van hierboven iets intuïtiever maken. Om een dynamisch type te maken, gebruiken we het keyword dynamic. Het vorige stukje code zou er dan als volgt uit gaan zien:
Assembly asm = Assembly.LoadFrom("DemoAssembly");
Type type = asm.GetType("Persoon");
Aan het ophalen van het type verandert helaas niets. Het interessante stuk komt nu.
dynamic inst = Activator.CreateInstance(type, new object{"Janssen", "Karel"});
Merk op dat de variabele inst nu een dynamisch type is geworden. Hierdoor zal de compiler verder acties op dit object, zoals het aanroepen van methodes of properties, niet meer checken. Nu kunnen we de StelJeVoor() methode aanroepen alsof die helemaal bekend zou zijn bij de compiler:
inst.StelJeVoor();
Natuurlijk moet de methode StelJeVoor() tijdens run-time wel bekend zijn anders gaat het alsnog fout. Dat probleem kan helaas (nog) niet verholpen worden. Ook Intellisense zal je niet helpen om de methode goed te spellen. Het blijft dus opletten geblazen.