Méthodes d’appel utilisant des noms en C #

J’ai un certain nombre de “travaux” dans ma candidature. Chaque travail contient une liste de méthodes à appeler, ainsi que ses parameters. On appelle essentiellement une liste contenant l’object suivant:

ssortingng Name; List Parameters;

En résumé, lorsqu’un travail est exécuté, je souhaite énumérer cette liste et appeler les méthodes appropriées. Par exemple, si j’ai une méthode comme celle-ci:

 TestMethod(ssortingng param1, int param2)

Mon object de méthode serait comme ceci:

 Name = TestMethod Parameters = "assortingng", 3

Est-il possible de faire cela? J’imagine que la reflection sera la clé ici.

Bien sûr, vous pouvez le faire comme ça:

 public class Test { public void Hello(ssortingng s) { Console.WriteLine("hello " + s); } } ... { Test t = new Test(); typeof(Test).GetMethod("Hello").Invoke(t, new[] { "world" }); // alternative if you don't know the type of the object: t.GetType().GetMethod("Hello").Invoke(t, new[] { "world" }); }

Le second paramètre de Invoke () est un tableau d’Object contenant tous les parameters à transmettre à votre méthode.

En supposant que les méthodes appartiennent toutes à la même classe, vous pouvez avoir une méthode de cette classe qui ressemble à ceci:

 public void InvokeMethod(ssortingng methodName, List

Si vous utilisez .NET Framework 4, examinez dynamic , sinon GetMethod , puis appelez Invoke of MethodInfo .

NuGet à la rescousse! PM> Install-Package dnpextensions

Une fois que vous avez ce package dans votre projet, tous les objects doivent maintenant avoir une extension .InvokeMethod() , qui prendra le nom de la méthode sous la forme d’une chaîne et d’un nombre quelconque de parameters.

Cela utilise techniquement des “chaînes magiques” pour les noms de méthodes, donc si vous voulez taper fortement votre dictionnaire de méthodes, vous pouvez créer les clés de type MethodInfo et les obtenir comme ceci …

 MethodInfo[] methodInfos = typeof(MyClass).GetMethods();

Et alors vous pouvez faire quelque chose comme ça …

 var methods = new Dictionary(); foreach (var item in methods) item.key.Invoke(null, item.value); // 'null' may need to be an instance of the object that // you are calling methods on if these are not static methods.

Ou vous pouvez faire une variante du bloc ci-dessus en utilisant les extensions de fichier que j’ai mentionnées précédemment.

Utilisez MethodBase.Invoke () . Devrait fonctionner jusqu’à .NET 2.0 avec System.Reflection .

Si vous avez recours à la reflection, il existe probablement un meilleur moyen d’accomplir votre tâche. Cela prendra peut-être un peu plus d’architecture, mais c’est faisable.

N’oubliez pas qu’avoir plus de code n’est pas une mauvaise chose, en particulier lorsqu’il complète la lisibilité et la facilité de gestion de votre code. La plupart du temps, la reflection est difficile à comprendre et vous perdez l’essentiel de votre sécurité lors de la compilation. Dans votre exemple, vous pourriez probablement vous contenter d’une instruction switch et d’objects distincts pour chaque méthode que vous envisagiez d’appeler. par exemple

 // Have some object hold the type of method it plans on calling. enum methodNames { Method1, Method2 } ... class someObject { internal methodNames methodName {get; set;} internal object[] myParams; } ... // Execute your object based on the enumeration value it references. switch(someObject1.methodName) { case Method1: Test.Method1(Int32.Parse(someObject1.myParams[0].ToSsortingng),someObject1.myParams[1].ToSsortingng()); break; ... }

Si vous savez que vous n’avez qu’une série de méthodes à appeler, pourquoi ne pas vous préparer à l’avance?