Call methods using names in C#

I have a number of 'jobs' in my application, where each job has a list of methods w开发者_如何学Chich it needs to call, along with it's parameters. Essentially a list containing the following object is called:

string Name;
List<object> Parameters;

So basically, when a job runs I want to enumerate through this list, and call the relevant methods. For example, if I have a method like the following:

TestMethod(string param1, int param2)

My method object would be like this:

Name = TestMethod
Parameters = "astring", 3

Is it possible to do this? I imagine reflection will be the key here.

Sure, you can do it like this:

public class Test
{
    public void Hello(string 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" }); 
}

The second parameter of Invoke() is an array of Object containing all the parameters to pass to your method.

Assuming the methods all belong to the same class, you could have a method of that class something like:

public void InvokeMethod(string methodName, List<object> args)
{
    GetType().GetMethod(methodName).Invoke(this, args.ToArray());
}

If you're using .NET Framework 4, look at dynamic, otherwise GetMethod and then call Invoke of MethodInfo.

Use MethodBase.Invoke(). Should work down to .NET 2.0 with System.Reflection.

If you're using having to resort to reflection, there is probably a better way to accomplish your task. It may take a little more architecture, but it's doable.

Remember, having more code isn't a bad thing -- especially when it compliments the readability and manageability of your code. Reflection is difficult to understand for most, and you lose most of your compile time type safety. In your example, you could probably just get away with a switch statement and distinct objects for each method you were planning to call. e.g.

// 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].ToString),someObject1.myParams[1].ToString());
      break;
   ...
}

If you know that you only have a distinct set of method possibilities to call, why not just set yourself up ahead of time?

NuGet to the rescue! PM> Install-Package dnpextensions

Once you have that package in your project, all objects should now have a .InvokeMethod() extension, that will take the method name as a string and any number of parameters.

That does technically use "magic strings" for the method names, so if you wanted to strongly-type your method dictionary, you could make the keys of type MethodInfo and get them like this...

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

And then you can do something like this...

var methods = new Dictionary<MethodInfo, Object[]>();
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.

Or you could do some variation of the above block using the dnpextensions I mentioned earlier.