Instanziieren einer Klasse

Bisher haben wir mit .NET Typen oder Objekten gearbeitet, die bereits instantiiert waren. Mit Reflection jedoch können wir dies auch zur Laufzeit tun, wenn wir den Namen der Klasse kennen, die wir instantiieren wollen. Es gibt mehrere Wege dies zu tun, aber ich ziehe es vor eine Referenz zum dem Konstruktor zu erstellen, den ich verwenden möchte, ihn aufzurufen und dann den Rückgabewert als meine Instanz zu nutzen. Hier ist ein Beispiel in dem genau das getan wird. Sieh dir den Code an, danach erklär ich alles.

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;
        }
    }
}

Ich habe zum Testen eine einfache Klasse definiert, die TestClass. Sie hat nur eine private Eigenschaft und eine öffentliche Methode. Die Methode gibt den Wert der privaten Eigenschaft zurück zu dem der Wert des übergebenen Parameters addiert wurde. Jetzt wollen wir eine neue Instanz der TestClass erstellen, die TestMethod aufrufen und das Ergebnis in die Konsole schreiben.

In diesem Beispiel haben wir den Vorteil, dass wir typeof() direkt auf der TestClass nutzen können, aber eventuell kommst du an einen Punkt, an dem du nur den Namen der gewünschten Klasse verwenden kannst. In diesem Fall kannst du eine Referenz darauf über den Assembly erhalten, wo sie deklariert ist, wie es im Kapitel über Typen gezeigt wurde.

Mit der Typen-Referenz zur Klasse können wir den defaultmäßigen Konstruktor erfragen, in dem wir die Methode GetConstructor() aufrufen und System.Type.EmptyTypes als Parameter übergeben. Falls wir einen bestimmten verwenden Konstruktor möchten, müssten wir ein Array zur Verfügung stellen, mit den Typen der Parameter, die der gesuchte Konstruktor erwartet.

Sobald wir eine Referenz auf den Konstruktor haben, können wir einfach die Invoke() Methode aufrufen um eine neue Instanz der TestClass zu erstellen. Wir übergeben null beim Aufrufen der Invoke()-Methode, da wir keine Parameter spezifizieren möchten. Mittels GetMethod() und dem Namen der Methode erhalten wir Zugriff auf die TestMethod()-Funktion und können nun wieder mittels Invoke() diese aufrufen. Diesmal müssen wir einen Parameter spezifizieren in Form von einem Array von Objekten. Wir machen das direkt im Aufruf und geben die Zahl 10 als einzigen Parameter an und geben zum Schluss das Ergebnis des Methodenaufrufs an. All das ermöglich die Magie der Reflektion!