Dynamically Invoke A Method, Given Strings with Method Name and Class Name

/// <summary>
/// executes a method belonging to an external namespace/project. it allows the use for any number of parameters (as objects)
/// </summary>
/// <param name="assembly" type="string">the project the namespace belongs to</param>
/// <param name="namesSpace" type="string">the namespace for which to find the class and method</param>
/// <param name="typeName" type="string">the class type that the method belongs to</param>
/// <param name="methodName" type="string">name of the method</param>
/// <param name="parameters" type="params object[]">one or more parameters for the method you wish to call</param>
/// <returns type="object">returns an object if it has anything to return</returns>
public static object execStaticString(string assembly, string nameSpace, string typeName, string methodName, params object[] parameters)
{

    //get the type of the class
    Type theType = Type.GetType(nameSpace + "." + typeName + "," + assembly);

    //invoke the method from the string. if there is anything to return, it returns to obj.
    object obj = theType.InvokeMember(methodName, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, parameters);

    //return the object if it exists
    return obj;

}//end static object execExtString(string,string,string,string,params object[])

/// <summary>
/// executes a method belonging to an external namespace/project. it allows the use for any number of parameters (as objects)
/// </summary>
/// <param name="classObject" type="object">the class instantiation that the method belongs to</param>
/// <param name="methodName" type="string">name of the method</param>
/// <param name="parameters" type="params object[]">one or more parameters for the method you wish to call</param>
/// <returns type="object">returns an object if it has anything to return</returns>
public static object execExtString(object classObject, string methodName, params object[] parameters)
{
    //invoke the method from the string. if there is anything to return, it returns to obj.
    object obj = classObject.GetType().InvokeMember(methodName, BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public, null, classObject, parameters);

    //return the object
    return obj;

}//end static object execExtString(string,string,string,string,params object[])

dudeserius wrote:

Type theType = Type.GetType(nameSpace + "." + typeName + "," + assembly);

Type theType = Type.GetType(String.Join(".", new string[] { nameSpace, typeName }));

Type theType = Type.GetType(String.Format("{0}.{1}, {2}", nameSpace, typeName, assembly));

using System;
using System.Linq;
using System.Reflection;

namespace BLL
{

    public class TypeUtils
    {

        /// ///////////////////// InvokeStringMethod //////////////////////
        ///
        /// <summary>
        /// Calls a static public method. 
        /// Assumes that the method returns a string, and doesn't have parameters.
        /// </summary>
        /// <param name="typeName">name of the class in which the method lives.</param>
        /// <param name="methodName">name of the method itself.</param>
        /// <returns>the string returned by the called method.</returns>
        /// 
        public static string InvokeStringMethod(string typeName, string methodName)
        {
            // Get the Type for the class
            Type calledType = Type.GetType(typeName);

            // Invoke the method itself. The string returned by the method winds up in s
            String s = (String)calledType.InvokeMember(
                            methodName,
                            BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                            null,
                            null,
                            null);

            // Return the string that was returned by the called method.
            return s;
        }

        /// ///////////////////// InvokeStringMethod2 //////////////////////
        ///
        /// <summary>
        /// Calls a static public method. 
        /// Assumes that the method returns a string, and takes a string parameter.
        /// </summary>
        /// <param name="typeName">name of the class in which the method lives.</param>
        /// <param name="methodName">name of the method itself.</param>
        /// <param name="stringParam">parameter passed to the method.</param>
        /// <returns>the string returned by the called method.</returns>
        /// 
        public static string InvokeStringMethod2(string typeName, string methodName, string stringParam)
        {
            // Get the Type for the class
            Type calledType = Type.GetType(typeName);

            // Invoke the method itself. The string returned by the method winds up in s.
            // Note that stringParam is passed via the last parameter of InvokeMember,
            // as an array of Objects.
            String s = (String)calledType.InvokeMember(
                            methodName,
                            BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                            null,
                            null,
                            new Object[] { stringParam });

            // Return the string that was returned by the called method.
            return s;
        }

        /// ///////////////////// InvokeStringMethod3 //////////////////////
        ///
        /// <summary>
        /// Calls a static public method. 
        /// Assumes that the method returns a string, and doesn't have parameters.
        /// </summary>
        /// <param name="assemblyName">name of the assembly containing the class in which the method lives.</param>
        /// <param name="namespaceName">namespace of the class.</param>
        /// <param name="typeName">name of the class in which the method lives.</param>
        /// <param name="methodName">name of the method itself.</param>
        /// <returns>the string returned by the called method.</returns>
        /// 
        public static string InvokeStringMethod3(string assemblyName, string namespaceName, string typeName, string methodName)
        {
            // Get the Type for the class
            Type calledType = Type.GetType(String.Format("{0}.{1},{2}", namespaceName, typeName, assemblyName));

            // Invoke the method itself. The string returned by the method winds up in s
            String s = (String)calledType.InvokeMember(
                            methodName,
                            BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                            null,
                            null,
                            null);

            // Return the string that was returned by the called method.
            return s;
        }

        #region AddedSection
        //Added functions by Matthew David Elgert - mdelgert@yahoo.com
        /// ///////////////////// InvokeStringMethod4 //////////////////////
        ///
        /// <summary>
        /// Calls a static public method. 
        /// Assumes that the method returns a string, and doesn't have parameters.
        /// </summary>
        /// <param name="assemblyName">name of the assembly containing the class in which the method lives.</param>
        /// <param name="namespaceName">namespace of the class.</param>
        /// <param name="typeName">name of the class in which the method lives.</param>
        /// <param name="methodName">name of the method itself.</param>
        /// /// <param name="stringParam">parameter passed to the method.</param>
        /// <returns>the string returned by the called method.</returns>
        /// 
        public static string InvokeStringMethod4(string assemblyName, string namespaceName, string typeName, string methodName, string stringParam)
        {
            // Get the Type for the class
            Type calledType = Type.GetType(String.Format("{0}.{1},{2}", namespaceName, typeName, assemblyName));

            // Invoke the method itself. The string returned by the method winds up in s.
            // Note that stringParam is passed via the last parameter of InvokeMember, as an array of Objects.
            String s = (String)calledType.InvokeMember(
                            methodName,
                            BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                            null,
                            null,
                            new Object[] { stringParam });

            // Return the string that was returned by the called method.
            return s;
        }

        /// ///////////////////// InvokeStringMethod5 //////////////////////
        ///
        /// <summary>
        /// Calls a static public method. 
        /// Assumes that the method returns a string
        /// </summary>
        /// <param name="assemblyName">name of the assembly containing the class in which the method lives.</param>
        /// <param name="namespaceName">namespace of the class.</param>
        /// <param name="typeName">name of the class in which the method lives.</param>
        /// <param name="methodName">name of the method itself.</param>
        /// <param name="stringParam">parameter passed to the method.</param>
        /// <returns>the string returned by the called method.</returns>
        /// 
        public static string InvokeStringMethod5(string assemblyName, string namespaceName, string typeName, string methodName, string stringParam)
        {
            //This method was created incase Method has params with default values. If has params will return error and not find function
            //This method will choice and is the preffered method for invoking 
            
            // Get the Type for the class
            Type calledType = Type.GetType(String.Format("{0}.{1},{2}", namespaceName, typeName, assemblyName));
            String s = null;

            // Invoke the method itself. The string returned by the method winds up in s.
            // Note that stringParam is passed via the last parameter of InvokeMember, as an array of Objects.

            if (MethodHasParams(assemblyName, namespaceName, typeName, methodName))
            {
                s = (String)calledType.InvokeMember(
                            methodName,
                            BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                            null,
                            null,
                            new Object[] { stringParam });
            }
            else
            {
                s = (String)calledType.InvokeMember(
                methodName,
                BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                null,
                null,
                null);
            }
            
            // Return the string that was returned by the called method.
            return s;

        }

        public static bool MethodHasParams(string assemblyName, string namespaceName, string typeName, string methodName)
        {
            bool HasParams;
            string name = String.Format("{0}.{1},{2}", namespaceName, typeName, assemblyName);
            Type calledType = Type.GetType(name);
            MethodInfo methodInfo = calledType.GetMethod(methodName);
            ParameterInfo[] parameters = methodInfo.GetParameters();
            
            if (parameters.Length > 0)
            {
                HasParams = true;
            }
            else
            {
                HasParams = false;
            }

            return HasParams;

        }

        #endregion

    }

}

//using objects for a generic approach that works with void and value returning methods
object obj = this.GetType().InvokeMember("DoThis", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public, null, this, null);

//if you want to invoke a method that is publicly accessible and owned by another class
//let's say you are in ClassA and you have instantiated another ClassA by the name of objB
object obj = objB.GetType().InvokeMember("DoThis", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public, null, objB, null);

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Reflection;

namespace ForPrintPre
{
    public partial class Form1 : Form
    {

        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            object obj = this.GetType().InvokeMember(textBox1.Text, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, null);
        }
        public void CallMe()
        {
            MessageBox.Show("In Call Me");
        }
    }
}

Quote:

object obj = this.GetType().InvokeMember(textBox1.Text, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, null);
At the runtime I'm getting error that "Method 'ForPrintPre.Form1.CallMe()' not found."

public static void CallMe()
{
   MessageBox.Show("In Call Me");
}

this.GetType().InvokeMember(textBox1.Text, BindingFlags.InvokeMethod | BindingFlags.Public, null, this, null);

public partial class dynamicMethodCall : Form
    {
        public dynamicMethodCall()
        {
            InitializeComponent();
        }
        
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {                
                this.GetType().InvokeMember(textBox1.Text, BindingFlags.InvokeMethod | BindingFlags.Public, null, this, null);
            }
            catch {
                MessageBox.Show("The function Not found..");
            }
        }
        public void CallMe()
        {
            MessageBox.Show("In Call Me Method.");
        }
}

this.GetType().InvokeMember(textBox1.Text, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, this, null);