As many developers know, one of the interesting namespaces in .NET is System.Reflection.
Here I try to use Reflection to invoke loaded assemblies’ methods by their names. This can be quite useful for applications like storing menu or button actions in a database and bringing them to life during runtime (I will post something about this subject shortly).
The attached test application demonstrates this in a very simple manner. Each dialog button invokes a method defined somewhere in the loaded assembly using its name. The search is done by few methods in MethodFinder static class.
The dialog displays 3 buttons. The OnClick handler for each button invokes a method by its name:
private void button1_Click(object sender, EventArgs e)
{
invoke_method("Method1");
}
private void button2_Click(object sender, EventArgs e)
{
invoke_method("Method2");
}
The invoke_method function, calls a method finder to retrieve the method and, if found, invokes it:
private void invoke_method(string method_name)
{
MethodInfo method = MethodFinder.FindMethod(method_name);
string str_result = "";
if (method != null)
{
str_result = method.Invoke(this, null).ToString();
MessageBox.Show(str_result);
}
else
MessageBox.Show("Couldn't find method in loaded assemblies");
}
What you should know
You probably know that a .NET assembly is composed of modules (generally just one module), each module is composed of classes (Types) and each class is composed of fields, properties and methods.
The MethodFinder.FindMethod function loops through runtime loaded assemblies, modules and classes to search for the method and return the found method if any.
FindMethod function:
public static MethodInfo FindMethod( string method_name)
{
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
method = FindAssemblyMethod( asm, method_name);
if( method != null)
return method;
}
return null;
}
FindAssemblyMethod function loops through assembly’s classes:
public static MethodInfo FindAssemblyMethod(Assembly asm, string method_name)
{
MethodInfo method;
foreach (Module module in asm.GetModules())
{
method = FindModuleMethod( module, method_name);
if( method != null)
return method;
}
return null;
}
As you have already guessed, FindModuleMethod function loops through module’s classes to search the method:
public static MethodInfo FindModuleMethod(Module module, string method_name)
{
Type[] module_types;
MethodInfo method;
module_types = module.GetTypes();
foreach (Type module_class in module_types)
{
method = FindClassMethod( module_class, method_name);
if( method != null)
return method;
}
return null;
}
Finally FindClassMethod searches for the method inside the class’s available methods:
public static MethodInfo FindClassMethod( Type module_class, string method_name)
{
MethodInfo[] methods;
methods = module_class.GetMethods();
foreach (MethodInfo method in methods)
{
if( string.Compare( method.Name, method_name, true) == 0)
return method;
}
return null;
}
This is a first approach that I believe that many useful applications can be built on.
I will expose some ideas on the subject in a next post.
Download the sample code (with some more details inside) InvokeMethodByName.zip (30.31 kb)