Calling methods selected in a ListBox

Question

I have an issue with a Windows Forms application that I am creating. The application is supposed to be an integration testing application. Essentially, it's supposed to test the methods that utilize lots of web services in one of my classes. I am loading the methods from the class I want to test via reflection, and am doing so like this:

private List<string> GetMethods(Type type)
{
    return (from method in type.GetMethods() where method.IsPublic &&
        method.ReturnType == typeof(void) select method.Name).ToList();
}

This returns a list of the methods from that class that have been created to test the web services and places them in a ListBox where the user can select as many methods as he/she likes. My confusion comes in here. What I would like to do is get the methods selected by the user and execute the corresponding method X amount of times (there is a text box for entering the number of times to execute a method on the form as well). I can't figure out how to execute these methods based on the name of the method I got through reflection. I've tried something like this, but I know it's not right:

private void RunMethods(Type type)
{
    var tester = new ClassToTest();
    foreach(var item in lstMethodList.SelectedItems)
    {
        foreach(var method in type.GetMethods())
        {
            if(String.Equals(item.ToString(), method.Name))
            {
                ThreadStart ts = new ThreadStart(method.Name);
                Thread thread1 = new Thread(ts);
                thread1.Start();
            }
         }
     }
}

This won't even compile, as a ThreadStart requires a method name as a parameter. Is there any way that this is possible to do? Maybe I'm going about it wrong logically, but I'd like to create a thread for each method that needs to be run and execute that method however many times the user specifies. This is supposed to be a way of doing integration testing along with some load testing to see what the web service can handle.

Answer 1

You can use something like this to get the methods you want:

private List<MethodInfo> GetMethods(Type type)
{
        return (from method in type.GetMethods()
                where method.IsPublic &&
                    method.ReturnType == typeof(void)
                select method).ToList();
}

Then if you want to call the methods in separate threads you would write (will work only if the methods are static):

foreach(MethodInfo mi in GetMethods(SomeType) {
   MethodInfo tempMi = mi;
   Action myAction = (Action) Delegate.CreateDelegate(typeof(Action), tempMi);
   ThreadStart ts = new ThreadStart(myAction);
   Thread thread1 = new Thread(ts);
   thread1.Start();
}

Or you would write (only if the methods have strictly no parameters, beware of inherited methods which may take parameters!):

foreach (MethodInfo mi in GetMethods(type))
{
   MethodInfo tempMi = mi; //modified closure
   object o = Activator.CreateInstance( type );
   Action myAction = delegate() { tempMi.Invoke(o, null); };
   ThreadStart ts = new ThreadStart(myAction);
   Thread thread1 = new Thread(ts);
   thread1.Start();
}

If the methods take parameters, you'd have to pass an array of object( object [] { ... } ) instead of null (in the Invoke method called on the current MethodInfo) accordingly; with of course corrects objects in the array.

It would actually be better if you take a List of Thread and add a new Thread in it for each MethodInfo in the list so you can keep control on them afterwards (like if you want to stop one). A HashMap would also be a good choice, the key being the MethodInfo or the Action and the value being the associated Thread.

Answer 2

You can implement a private dictionary which holds the MethodInfos and Method name.

private Dictionary<string, MethodInfo> methodList;
        private List<string> GetMethods(Type type)
        {
            methodList = new Dictionary<string, MethodInfo>();

            type.GetMethods().Where(m=>m.IsPublic && m.ReturnType.Equals(typeof(void))).ToList().ForEach(m=>
                methodList.Add(m.Name,m)
                );

            return methodList.Keys.Select(k => k).ToList();
        }

on selecting the dropdown, you can find the method in the dictionary and execute it.

Answer 3

You can create an instance of your class using Activator.

Then you can call one of its methods using Invoke.

Something like this should work:

private void RunMethods(Type type)
{
    foreach( var item in lstMethodList.SelectedItems )
    {
        foreach( var method in type.GetMethods() )
        {
            if( String.Equals( item.ToString(), method.Name))
            {
                MethodInfo capturedMethod = method;
                var t = new Thread( () => ThreadMain( type, capturedMethod ) );
                t.Start();
            }
         }
     }
}

static void ThreadMain( Type type, MethodInfo mi )
{
    object o = Activator.CreateInstance( type );

    object[] parameters = new object[] { };

    mi.Invoke( o, parameters );
}

I've assumed the class being tested has a parameter-less constructor.