Comment puis-je utiliser la réflexion pour appeler une méthode générique?

Vous devez utiliser la réflexion pour obtenir la méthode pour commencer, puis "construire" en fournissant des arguments de type avec MakeGenericMethod:

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);

Pour une méthode statique, passer null comme premier argument de Invoke. Ce n'est rien à faire avec des méthodes génériques - c'est tout à fait normal de réflexion.

Comme indiqué, un grand nombre de ce qui est plus simple que de C# 4 à l'aide de dynamic - si vous pouvez utiliser l'inférence de type, bien sûr. Il ne l'aide pas dans les cas où l'inférence de type n'est pas disponible, comme l'exemple précis de la question.

OriginalL'auteur Jon Skeet

L'appel d'une méthode générique avec un paramètre de type connu qu'à l'exécution peut être grandement simplifiée par l'utilisation d'un dynamique type, au lieu de l'API reflection.

À l'utilisation de cette technique, le type doit être connue de l'objet réel (et pas seulement une instance de la Type classe). Sinon, vous devez créer un objet de ce type ou de l'utilisation de la norme API reflection solution. Vous pouvez créer un objet en utilisant le Activateur.CreateInstance méthode.

Si vous voulez appeler une méthode générique, qu'en "normal" d'utilisation aurait eu son type inféré, alors qu'il vient tout simplement de la coulée de l'objet de type inconnu à dynamic. Voici un exemple:

class Alpha { }
class Beta { }
class Service
{
    public void Process<T>(T item)
    {
        Console.WriteLine("item.GetType(): " + item.GetType()
                          + "\ttypeof(T): " + typeof(T));
    }
}

class Program
{
    static void Main(string[] args)
    {
        var a = new Alpha();
        var b = new Beta();

        var service = new Service();
        service.Process(a); //Same as "service.Process<Alpha>(a)"
        service.Process(b); //Same as "service.Process<Beta>(b)"

        var objects = new object[] { a, b };
        foreach (var o in objects)
        {
            service.Process(o); //Same as "service.Process<object>(o)"
        }
        foreach (var o in objects)
        {
            dynamic dynObj = o;
            service.Process(dynObj); //Or write "service.Process((dynamic)o)"
        }
    }
}

Et voici la sortie de ce programme:

item.GetType(): Alpha    typeof(T): Alpha
item.GetType(): Beta     typeof(T): Beta
item.GetType(): Alpha    typeof(T): System.Object
item.GetType(): Beta     typeof(T): System.Object
item.GetType(): Alpha    typeof(T): Alpha
item.GetType(): Beta     typeof(T): Beta

Process générique est une méthode d'instance qui écrit le vrai type de l'argument passé (à l'aide de la GetType() méthode) et le type de paramètre générique (à l'aide de typeof opérateur).

Par moulage de l'objet argument dynamic type nous avons reporté fournir le type de paramètre jusqu'à ce que l'exécution. Lorsque le Process méthode est appelée avec le dynamic argument alors le compilateur n'est pas le type de cet argument. Le compilateur génère du code qui au moment de l'exécution de vérifications de la vraie types d'arguments passés (par réflexion) et de choisir la meilleure méthode à appeler. Ici, il n'y a qu'une méthode générique, si elle est appelée avec un paramètre de type.

Dans cet exemple, la sortie est la même que si vous avez écrit:

foreach (var o in objects)
{
    MethodInfo method = typeof(Service).GetMethod("Process");
    MethodInfo generic = method.MakeGenericMethod(o.GetType());
    generic.Invoke(service, new object[] { o });
}

La version avec un type dynamique est nettement plus court et plus facile à écrire. Vous aussi vous ne devriez pas vous soucier de la performance à l'appel de cette fonction plusieurs fois. Le prochain appel de la fonction avec des arguments du même type devrait être plus rapide grâce à la la mise en cache mécanisme de DLR. Bien sûr, vous pouvez écrire du code qui cache invoquée délégués, mais par l'aide de la dynamic type que vous obtenez ce comportement pour gratuit.

Si le générique de la méthode que vous voulez l'appeler n'avez pas un argument d'un paramétrées type (de sorte que son type de paramètre ne peut pas être déduite), alors vous pouvez envelopper l'invocation de la méthode générique dans une méthode d'aide comme dans l'exemple suivant:

class Program
{
    static void Main(string[] args)
    {
        object obj = new Alpha();

        Helper((dynamic)obj);
    }

    public static void Helper<T>(T obj)
    {
        GenericMethod<T>();
    }

    public static void GenericMethod<T>()
    {
        Console.WriteLine("GenericMethod<" + typeof(T) + ">");
    }
}

Augmenté de sécurité de type

Ce qui est vraiment bien sur l'utilisation de dynamic objet comme un remplacement pour l'utilisation de la réflexion de l'API, c'est que vous ne perdez au moment de la compilation, la vérification de ce type particulier que vous ne savez pas jusqu'à l'exécution. D'autres arguments et le nom de la méthode sont staticly analysés par le compilateur comme d'habitude. Si vous supprimez ou ajoutez plus d'arguments, de modifier leurs types ou de renommer le nom de la méthode, vous obtiendrez une erreur de compilation. Cela ne se produira pas si vous fournissez le nom de la méthode comme une chaîne de caractères dans Type.GetMethod et les arguments que les objets de tableau dans MethodInfo.Invoke.

Ci-dessous est un exemple simple qui illustre la façon dont certaines erreurs peuvent être pris au moment de la compilation (code commenté) et d'autres au moment de l'exécution. Il montre aussi comment le DLR essaie de résoudre la méthode à appeler.

interface IItem { }
class FooItem : IItem { }
class BarItem : IItem { }
class Alpha { }

class Program
{
    static void Main(string[] args)
    {
        var objects = new object[] { new FooItem(), new BarItem(), new Alpha() };
        for (int i = 0; i < objects.Length; i++)
        {
            ProcessItem((dynamic)objects[i], "test" + i, i);

            //ProcesItm((dynamic)objects[i], "test" + i, i);
            //compiler error: The name 'ProcesItm' does not
            //exist in the current context

            //ProcessItem((dynamic)objects[i], "test" + i);
            //error: No overload for method 'ProcessItem' takes 2 arguments
        }
    }

    static string ProcessItem<T>(T item, string text, int number)
        where T : IItem
    {
        Console.WriteLine("Generic ProcessItem<{0}>, text {1}, number:{2}",
                          typeof(T), text, number);
        return "OK";
    }
    static void ProcessItem(BarItem item, string text, int number)
    {
        Console.WriteLine("ProcessItem with Bar, " + text + ", " + number);
    }
}

Ici, nous avons de nouveau exécuter une méthode de coulée de l'argument de la dynamic type. Seulement la vérification de la première de l'argument type est reportée au moment de l'exécution. Vous obtiendrez une erreur de compilation si le nom de la méthode que vous avez demandé n'existe pas ou si d'autres arguments ne sont pas valides (mauvais nombre d'arguments ou de mauvais types).

Quand vous passez le dynamic argument d'une méthode, puis cet appel est dernièrement lié. Surcharge de la méthode de résolution qui se passe lors de l'exécution et tente de choisir le meilleur de surcharge. Donc, si vous appelez la ProcessItem méthode à un objet de BarItem type, alors vous aurez fait appel à la non-méthode générique, parce qu'il est un meilleur match pour ce type. Toutefois, vous obtiendrez une erreur d'exécution lorsque vous passez un argument de la Alpha type car il n'y a pas de méthode qui peut manipuler cet objet (une méthode générique a la contrainte where T : IItem et Alpha classe n'implémente cette interface). Mais c'est l'ensemble de point. Le compilateur n'a pas l'information que cet appel est valide. Vous en tant que programmeur sait cela, et vous devez vous assurer que ce code s'exécute sans erreur.

Type de retour gotcha

Lorsque vous appelez un non-nulle méthode avec un paramètre de type dynamique, son type de retour ne sera probablement dynamique trop. Donc, si vous souhaitez modifier l'exemple précédent du présent code:

var result = ProcessItem((dynamic)testObjects[i], "test" + i, i);

alors le type de l'objet de résultat serait dynamic. C'est parce que le compilateur ne sait pas toujours la méthode qui sera appelée. Si vous connaissez le type de retour de l'appel de la fonction, alors vous devriez convertir implicitement pour le type requis de sorte que le reste du code est statiquement typé:

string result = ProcessItem((dynamic)testObjects[i], "test" + i, i);

Vous obtiendrez une erreur d'exécution si le type ne correspond pas.

En fait, si vous essayez d'obtenir le résultat de la valeur dans l'exemple précédent, vous obtiendrez une erreur d'exécution dans la deuxième itération de boucle. C'est parce que vous avez essayé de sauvegarder la valeur de retour d'une fonction void.

OriginalL'auteur Mariusz Pawelski

Ajoutant à Adrian Gallero réponse:

L'appel d'une méthode générique de type info déroule en trois étapes.

TLDR: Appel connue méthode générique d'un type d'objet qui peut être accompli par:

((Action)GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition()
    .MakeGenericMethod(typeof(string))
    .Invoke(this, null);

où GenericMethod<object> est le nom de la méthode à appeler et à n'importe quel type qui satisfait aux contraintes génériques.

(Action) correspond à la signature de la méthode à appeler à savoir (Func<string,string,int> ou Action<bool>)

L'étape 1 est d'obtenir le MethodInfo pour le générique de la définition de la méthode de

Méthode 1: Utiliser GetMethod() ou GetMethods() avec les types appropriés ou de liaison drapeaux.

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");

Méthode 2: Créer un délégué, obtenir le MethodInfo objet et ensuite appeler GetGenericMethodDefinition

De l'intérieur de la classe qui contient des méthodes:

MethodInfo method = ((Action)GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition();

MethodInfo method = ((Action)StaticMethod<object>)
    .Method
    .GetGenericMethodDefinition();

De l'extérieur de la classe qui contient des méthodes:

MethodInfo method = ((Action)(new Sample())
    .GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition();

MethodInfo method = ((Action)Sample.StaticMethod<object>)
    .Method
    .GetGenericMethodDefinition();

En C#, le nom d'une méthode, c'est à dire "ToString" ou "GenericMethod" fait référence à un groupe de méthodes qui peuvent contenir une ou plusieurs méthodes. Jusqu'à ce que vous offrent les types des paramètres de la méthode, on ne sait pas qui
la méthode que vous faites allusion.

((Action)GenericMethod<object>) se réfère à la délégué pour une méthode spécifique. ((Func<string, int>)GenericMethod<object>)
se réfère à une autre surcharge de GenericMethod

Méthode 3: Créer une lambda expression contenant un appel de méthode d'expression, d'obtenir le MethodInfo objet, puis GetGenericMethodDefinition

MethodInfo method = ((MethodCallExpression)((Expression<Action<Sample>>)(
    (Sample v) => v.GenericMethod<object>()
    )).Body).Method.GetGenericMethodDefinition();

Cela revient à

Créer une expression lambda où le corps est un appel à votre méthode souhaitée.

Expression<Action<Sample>> expr = (Sample v) => v.GenericMethod<object>();

Extraire le corps et jeté à MethodCallExpression

MethodCallExpression methodCallExpr = (MethodCallExpression)expr.Body;

Obtenir le générique de la définition de la méthode de la méthode

MethodInfo methodA = methodCallExpr.Method.GetGenericMethodDefinition();

L'étape 2 est l'appel de MakeGenericMethod pour créer une méthode générique avec le type approprié(s).

MethodInfo generic = method.MakeGenericMethod(myType);

L'étape 3 est en invoquant la méthode avec les arguments appropriés.

generic.Invoke(this, null);

OriginalL'auteur Grax

C'est mes 2 cents basé sur Grax réponse, mais avec deux paramètres requis pour une méthode générique.

Supposons que votre méthode est définie comme suit dans un Helpers classe:

public class Helpers
{
    public static U ConvertCsvDataToCollection<U, T>(string csvData)
    where U : ObservableCollection<T>
    {
      //transform code here
    }
}

Dans mon cas, U est toujours de type une collection observable stockage objet de type T.

Que j'ai mon des types prédéfinis, j'ai d'abord créer le "dummy" des objets qui représentent la collection observable (U) et de l'objet stocké dans celui-ci (T) et qui sera utilisé ci-dessous pour obtenir leur type lors de l'appel de la Faire

object myCollection = Activator.CreateInstance(collectionType);
object myoObject = Activator.CreateInstance(objectType);

Puis d'appeler le GetMethod pour trouver votre fonction Générique:

MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");

Jusqu'à présent, l'appel ci-dessus est à peu près identique à ce qui a été expliqué ci-dessus, mais avec une petite différence quand vous avez besoin d'avoir à passer plusieurs paramètres.

Vous avez besoin pour passer d'un Type tableau[] à la MakeGenericMethod fonction qui contient le "dummy" objets " de types qui ont été créer ci-dessus:

MethodInfo generic = method.MakeGenericMethod(
new Type[] {
   myCollection.GetType(),
   myObject.GetType()
});

Une fois cela fait, vous devez appeler la méthode Invoke comme mentionné ci-dessus.

generic.Invoke(null, new object[] { csvData });

Et vous avez terminé. Fonctionne à merveille!

Mise à JOUR:

@Bevan mis en évidence, je n'ai pas besoin de créer un tableau lors de l'appel de la MakeGenericMethod fonctionner comme il faut dans les paramètres et je n'ai pas besoin de créer un objet afin d'obtenir les types que je peux simplement passer les types directement à cette fonction. Dans mon cas, depuis que j'ai les types prédéfinis dans une autre classe, j'ai simplement changé mon code:

object myCollection = null;

MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");

MethodInfo generic = method.MakeGenericMethod(
   myClassInfo.CollectionType,
   myClassInfo.ObjectType
);

myCollection = generic.Invoke(null, new object[] { csvData });

myClassInfo contient 2 propriétés de type Type que j'ai mis lors de l'exécution basée sur une valeur d'enum transmis au constructeur et me fournir les types pertinents que j'utilise ensuite dans le MakeGenericMethod.

Merci encore pour mettre en évidence cette @Bevan.

OriginalL'auteur Thierry