Passer D'Un Système Instancié.Type de Type de Paramètre pour une Classe Générique

Vous ne pouvez pas faire cela sans réflexion. Cependant, vous peut le faire avec la réflexion. Voici un exemple complet:

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

Remarque: si votre classe générique accepte plusieurs types, vous devez inclure les virgules si vous omettez les noms de type, par exemple:

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

Quelques autres, comment courir avec des ciseaux code. Supposons que vous avez une classe similaire à

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

Supposons que lors de l'exécution, vous avez un FooContent

Si vous avez été capable de se lier au moment de la compilation que vous voulez

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

Cependant vous ne pouvez pas le faire au moment de l'exécution. Pour ce faire, au moment de l'exécution que vous feriez le long des lignes de:

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

Pour invoquer dynamiquement Markdown(IEnumerable<FooContent> contents)

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

Remarque l'utilisation de dynamic dans l'appel de méthode. Au moment de l'exécution dynamicList sera List<FooContent> (en outre également être IEnumerable<FooContent>), puisque même l'utilisation de la dynamique est toujours enraciné dans un langage fortement typé, le temps d'exécution classeur de sélectionner la Markdown méthode. Si il n'est pas exacte type de matchs, il va chercher un objet en paramètre de la méthode et si aucun match de l'exécution de liant exception sera levée d'alerte qu'aucune méthode matchs.

Le tirage évident de retour de cette approche est une énorme perte de sécurité de type au moment de la compilation. Néanmoins code le long de ces lignes qui vont vous permettre de fonctionner dans un très dynamique en ce sens qu'au moment de l'exécution est encore entièrement tapé comme vous l'attendez.

Si vous savez quels types seront écoulées, vous pouvez le faire sans réflexion. Une instruction switch serait de travailler. Bien évidemment, cela ne fonctionne que dans un nombre limité de cas, mais il sera beaucoup plus rapide que de réflexion.

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