Dynamically load a class and execute a method in .NET

//Arguments for Class Constructor. If you want to use default class constructor w/o any arguments just leave the array empty like this Object[] classConstructorArgs = {};
Object[] classConstructorArgs = {@"OneArgForClassConstructor"};
 
Object[] methodArgs = {1, "2", 3.0};
 
Object Result = DynaInvoke.InvokeMethodSlow("c:\FullPathToDll.DLL", 
                                            "ClassName",
                                            "MethodName",
                                            classConstructorArgs,
                                            methodArgs);

using System;
using System.Reflection;
using System.Collections;
 
namespace XYZ
{
    public class DynaInvoke
    {
        // this way of invoking a function

        // is slower when making multiple calls

        // because the assembly is being instantiated each time.

        // But this code is clearer as to what is going on

        public static Object InvokeMethodSlow(string AssemblyName,
               string ClassName, string MethodName, Object[] cArgs, Object[] mArgs)
        {
            // load the assemly

            Assembly assembly = Assembly.LoadFrom(AssemblyName);
 
            // Walk through each type in the assembly looking for our class

            foreach (Type type in assembly.GetTypes())
            {
                if (type.IsClass == true)
                {
                    if (type.FullName.EndsWith("." + ClassName))
                    {
                        // create an instance of the object

                        //object ClassObj = Activator.CreateInstance(type);
                        object ClassObj = Activator.CreateInstance(type, cArgs);
 
                        // Dynamically Invoke the method

                        object Result = type.InvokeMember(MethodName,
                          BindingFlags.Default | BindingFlags.InvokeMethod,
                               null,
                               ClassObj,
                               mArgs);
                        return (Result);
                    }
                }
            }
            throw (new System.Exception("could not invoke method"));
        }
 
        // ---------------------------------------------

        // now do it the efficient way

        // by holding references to the assembly

        // and class

 
        // this is an inner class which holds the class instance info

        public class DynaClassInfo
        {
            public Type type;
            public Object ClassObject;
 
            public DynaClassInfo()
            {
            }
 
            public DynaClassInfo(Type t, Object c)
            {
                type = t;
                ClassObject = c;
            }
        }
 

        public static Hashtable AssemblyReferences = new Hashtable();
        public static Hashtable ClassReferences = new Hashtable();
 
        public static DynaClassInfo
               GetClassReference(string AssemblyName, string ClassName)
        {
            if (ClassReferences.ContainsKey(AssemblyName) == false)
            {
                Assembly assembly;
                if (AssemblyReferences.ContainsKey(AssemblyName) == false)
                {
                    AssemblyReferences.Add(AssemblyName,
                          assembly = Assembly.LoadFrom(AssemblyName));
                }
                else
                    assembly = (Assembly)AssemblyReferences[AssemblyName];
 
                // Walk through each type in the assembly

                foreach (Type type in assembly.GetTypes())
                {
                    if (type.IsClass == true)
                    {
                        // doing it this way means that you don't have

                        // to specify the full namespace and class (just the class)

                        if (type.FullName.EndsWith("." + ClassName))
                        {
                            DynaClassInfo ci = new DynaClassInfo(type,
                                               Activator.CreateInstance(type));
                            ClassReferences.Add(AssemblyName, ci);
                            return (ci);
                        }
                    }
                }
                throw (new System.Exception("could not instantiate class"));
            }
            return ((DynaClassInfo)ClassReferences[AssemblyName]);
        }
 
        public static Object InvokeMethod(DynaClassInfo ci,
                             string MethodName, Object[] args)
        {
            // Dynamically Invoke the method

            Object Result = ci.type.InvokeMember(MethodName,
              BindingFlags.Default | BindingFlags.InvokeMethod,
                   null,
                   ci.ClassObject,
                   args);
            return (Result);
        }
 
        // --- this is the method that you invoke ------------

        public static Object InvokeMethod(string AssemblyName,
               string ClassName, string MethodName, Object[] args)
        {
            DynaClassInfo ci = GetClassReference(AssemblyName, ClassName);
            return (InvokeMethod(ci, MethodName, args));
        }
    }
}

        public static Object InvokeMethod( DynaClassInfo ci,
                             string MethodName, Object[] args )
        {
            // Dynamically Invoke the method

            /*** 
             * The Type.InvokeMember method is not supported in the
             * Compact Framework.
             ***/
            //Object Result = ci.type.InvokeMember( MethodName,
            //  BindingFlags.Default | BindingFlags.InvokeMethod,
            //       null,
            //       ci.ClassObject,
            //       args );

            MethodInfo method = ci.type.GetMethod( MethodName );
            Object Result = method.Invoke( ci.ClassObject, args );
 
            return (Result);
        }