Een class instantiëren

So far, we have worked with .NET types or objects already instantiated. But with Reflection, we can actually do the instantiation at runtime as well, knowing the name of the class we wish to instantiate. There are several ways of doing it, but I prefer getting a reference to the constructor that I wish to use, invoke it, and then use the returned value as my instance. Here's an example of doing just that. Code first, then I will explain it all:

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace ReflectionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Type testType = typeof(TestClass);
            ConstructorInfo ctor = testType.GetConstructor(System.Type.EmptyTypes);
            if(ctor != null)
            {
                object instance = ctor.Invoke(null);
                MethodInfo methodInfo = testType.GetMethod("TestMethod");
                Console.WriteLine(methodInfo.Invoke(instance, new object[] { 10 }));
            }
            Console.ReadKey();
        }
    }

    public class TestClass
    {
        private int testValue = 42;

        public int TestMethod(int numberToAdd)
        {
            return this.testValue + numberToAdd;
        }
    }
}

Ik heb een simpele class gedefinieerd om dit te testen, met de naam TestClass. Hij omvat een private veld en een public method. De method retourneert de waarde van de private property, met de waarde van de parameter eraan toegevoegd. Wat we nu willen is een nieuw exemplaar van deze TestClass creëren, de testMethod oproepen en het resultaat naar de console sturen.

In dit voorbeeld hebben we de luxe om de typof() direct bij de TestClass te kunnen gebruiken, maar op een gegeven moment moet je het alleen doen door de naam van de gewenste class te gebruiken. In dat geval kun je er een referentie naartoe krijgen door de assembly waar hij is gedeclareerd, zoals gedemonstreerd in het hoofdstuk over Type

Dus met een Type referentie naar de class, vragen we om de default constructor door gebruik van de GetConstructor() method, waarbij we System.Type.EmptyTypes als parameter stellen. Als we een specifieke constructor wilden, zouden we een array van Type's moeten leveren, waarvan elk definieert welke parameter de constructor, waar we naar zochten, zou nemen.

Once we have a reference to the constructor, we simply call the Invoke() method to create a new instance of the TestClass class. We pass null as the parameter to Invoke(), since we're not looking to specify any parameters. We use the GetMethod(), along with the name of the method we want, to get the TestMethod() function, and then we once again use the magic of the Invoke() method to call this function. This time we need to specify a parameter, in the form of an array of objects. We do that on-the-fly, specifying the number 10 as the only parameter we need, and we then output the result of the method invocation. All of this through the magic of Reflection!