Übergeben Sie ein instanziiertes System.Type als Typparameter für eine generische Klasse

Der Titel ist irgendwie dunkel. Ich möchte wissen, ob dies möglich ist:

string typeName = <read type name from somwhere>;
Type myType = Type.GetType(typeName);

MyGenericClass<myType> myGenericClass = new MyGenericClass<myType>();

Offensichtlich wird MyGenericClass wie folgt beschrieben:

public class MyGenericClass<T>

Im Moment beschwert sich der Compiler, dass 'Der Typ oder Namespace' myType 'nicht gefunden werden konnte. "Es muss einen Weg geben, dies zu tun.

Sie können dies nicht ohne Reflexion tun. Sie können dies jedoch mit Reflexion tun. Hier ist ein vollständiges Beispiel:

using System;
using System.Reflection;

public class Generic<T>
{
    public Generic()
    {
        Console.WriteLine("T={0}", typeof(T));
    }
}

class Test
{
    static void Main()
    {
        string typeName = "System.String";
        Type typeArgument = Type.GetType(typeName);

        Type genericClass = typeof(Generic<>);
        // MakeGenericType is badly named
        Type constructedClass = genericClass.MakeGenericType(typeArgument);

        object created = Activator.CreateInstance(constructedClass);
    }
}

Hinweis: Wenn Ihre generische Klasse mehrere Typen akzeptiert, müssen Sie die Kommas einfügen, wenn Sie die Typnamen weglassen. Beispiel:

Type genericClass = typeof(IReadOnlyDictionary<,>);
Type constructedClass = genericClass.MakeGenericType(typeArgument1, typeArgument2);

Leider nein gibt es nicht. Generische Argumente müssen zur Kompilierungszeit entweder als 1) gültiger Typ oder 2) als anderer generischer Parameter auflösbar sein. Es gibt keine Möglichkeit, generische Instanzen basierend auf Laufzeitwerten zu erstellen, ohne den großen Hammer der Verwendung von Reflektion.

Einige zusätzliche Anweisungen zum Ausführen mit Scherencode. Angenommen, Sie haben eine ähnliche Klasse wie

public class Encoder() {
public void Markdown(IEnumerable<FooContent> contents) { do magic }
public void Markdown(IEnumerable<BarContent> contents) { do magic2 }
}

Angenommen, Sie haben zur Laufzeit einen FooContent

Wenn Sie zur Kompilierungszeit binden könnten, würden Sie wollen

var fooContents = new List<FooContent>(fooContent)
new Encoder().Markdown(fooContents)

Allerdings können Sie diese zur Laufzeit nicht. Um dies zur Laufzeit zu tun, würden Sie Folgendes tun:

var listType = typeof(List<>).MakeGenericType(myType);
var dynamicList = Activator.CreateInstance(listType);
((IList)dynamicList).Add(fooContent);

Dynamisch aufrufen Markdown(IEnumerable<FooContent> contents)

new Encoder().Markdown( (dynamic) dynamicList)

Beachten Sie die Verwendung von dynamicim Methodenaufruf. Zur Laufzeit dynamicListwird List<FooContent>(zusätzlich auch IEnumerable<FooContent>) sein, da selbst die Verwendung von Dynamic noch in einer stark typisierten Sprache verwurzelt ist, wählt der Laufzeitbinder die entsprechende ausMarkdown Methode aus. Wenn keine genauen Typübereinstimmungen vorhanden sind, wird nach einer Objektparameter-Methode gesucht. Wenn keine übereinstimmen, wird eine Laufzeitbinder-Ausnahme ausgelöst, die darauf hinweist, dass keine Methode übereinstimmt.

Der offensichtliche Nachteil dieses Ansatzes ist ein enormer Verlust an Typensicherheit beim Kompilieren. Mit Code in dieser Richtung können Sie jedoch in einem sehr dynamischen Sinne arbeiten, der zur Laufzeit immer noch vollständig so eingegeben wird, wie Sie es erwarten.

Meine Anforderungen waren etwas anders, werden aber hoffentlich jemandem helfen. Ich musste den Typ aus einer Konfiguration lesen und den generischen Typ dynamisch instanziieren.

namespace GenericTest
{
    public class Item
    {
    }
}

namespace GenericTest
{
    public class GenericClass<T>
    {
    }
}

Zum Schluss nennen Sie es so. Definieren Sie den Typ mit einem Backtick .

var t = Type.GetType("GenericTest.GenericClass`1[[GenericTest.Item, GenericTest]], GenericTest");
var a = Activator.CreateInstance(t);

Wenn Sie wissen, welche Typen übergeben werden, können Sie dies ohne Reflexion tun. Eine switch-Anweisung würde funktionieren. Natürlich würde dies nur in einer begrenzten Anzahl von Fällen funktionieren, aber es wird viel schneller sein als Reflexion.

public class Type1 { }

public class Type2 { }

public class Generic<T> { }

public class Program
{
    public static void Main()
    {
        var typeName = nameof(Type1);

        switch (typeName)
        {
            case nameof(Type1):
                var type1 = new Generic<Type1>();
                // do something
                break;
            case nameof(Type2):
                var type2 = new Generic<Type2>();
                // do something
                break;
        }
    }
}

In diesem Snippet möchte ich zeigen, wie eine dynamisch erstellte Liste erstellt und verwendet wird. Zum Beispiel füge ich hier der dynamischen Liste hinzu.

void AddValue<T>(object targetList, T valueToAdd)
{
    var addMethod = targetList.GetType().GetMethod("Add");
    addMethod.Invoke(targetList, new[] { valueToAdd } as object[]);
}

var listType = typeof(List<>).MakeGenericType(new[] { dynamicType }); // dynamicType is the type you want
var list = Activator.CreateInstance(listType);

AddValue(list, 5);

Ebenso können Sie jede andere Methode in der Liste aufrufen.