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

Matt Perdeck

Rate this:

7 Aug 2007CPOL

Sometimes you need to compute the name of a method into a string. This article shows how to call a method given a string with the method's name and class.

Download source - 17.02 KB

Introduction

I recently needed to write some code that would compute the name of a method into a string, and then call that method as shown below:

string s1 = "The";
string s2 = "Method";
string methodName = s1 + s2; // methodName now holds "TheMethod"
    
... code that somehow calls the method whose name is in variable methodName
... in this case, the method TheMethod

Like so many things in .NET, this turned out to be easy - as long as you know how to do it.

Simple Solution

Below is the code that will do the trick, wrapped in the method InvokeStringMethod. As you see, it takes only two lines to call another method given its name as a string, and its class name also as a string. Read the comments in the code to see how it works.

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;
}

This method assumes that the called method has no parameters and returns a string. Pass the name of the method in parameter methodName, and the name of its class in typeName. For example:

string s = string InvokeStringMethod("TheClass", "TheMethod");

Pass a Parameter to the Called Method

Below is a version that calls a method that expects one parameter of type string.

Have a look at the code. Passing parameters to the called function is simply a matter of passing them to InvokeMember as an array of Objects. InvokeMember in turn passes those objects on as parameters to the called method.

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;
}

When you call this version, pass a string in parameter stringParam. InvokeStringMethod2 will pass that string on to the called method. For example:

string s = string InvokeStringMethod2("TheClass", "TheMethod", "The string to pass on");

Call a Method in Another Project and Namespace

You may have organised your code into several projects and namespaces. The version below calls a method that may sit in a different project and/or namespace than the caller. (This version assumes that the called method doesn't take parameters.)

 public static string InvokeStringMethod3(
                        string assemblyName,
                        string namespaceName,
                        string typeName,
                        string methodName)
{
    // Get the Type for the class
    Type calledType = Type.GetType(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;
}

It assumes that each project gets compiled into its own assembly, with project and assembly having the same name. This is normally the case.

Be sure to add a reference in the project that makes the call to the project that contains the called method! Otherwise, the code can't find the assembly.

When you call this version, pass in the name of the project and the namespace as well as the class name and method name. Like so:

string s = string InvokeStringMethod3
            ("TheProject", "TheNamespace", "TheClass", "TheMethod");

Learn More

When looking at the code above, you will have found that calling a method given a string with its name takes two steps:

Call method GetType of class Type, to get the Type corresponding to the class that contains the method.
Call method InvokeMember on the type, to actually call the method.

To learn more, search MSDN for Type.GetType, and InvokeMember.

Some of the more interesting options include calling private methods rather than public ones, and picking a particular overloaded method.

Have a Play

To experiment a bit more, get the download that comes with this article. It has a tiny Web site serving as a test bed.

The most important files in the download are listed below:

DynamicallyInvokeMethodGivenItsNameAsAString.sln - Double click this file to open the solution in Visual Studio
Default.aspx.cs - Calls the three versions shown above
App_Code/TypeUtils.cs - The class holding the three versions
App_Code/TestClass, App_Code/TestClass2 - Classes with methods to call
TestClass3 in project TestProject - A class in a separate project, with a different namespace

History

7^th August, 2007: Initial post

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Matt Perdeck

	Architect
	Australia

Twitter: @MattPerdeck
LinkedIn: au.linkedin.com/in/mattperdeck
Current project: JSNLog JavaScript Logging Package

Matt has over 9 years .NET and SQL Server development experience. Before getting into .Net, he worked on a number of systems, ranging from the largest ATM network in The Netherlands to embedded software in advanced Wide Area Networks and the largest ticketing web site in Australia. He has lived and worked in Australia, The Netherlands, Slovakia and Thailand.

He is the author of the book ASP.NET Performance Secrets (www.amazon.com/ASP-NET-Site-Performance-Secrets-Perdeck/dp/1849690685) in which he shows in clear and practical terms how to quickly find the biggest bottlenecks holding back the performance of your web site, and how to then remove those bottlenecks. The book deals with all environments affecting a web site - the web server, the database server and the browser.

Matt currently lives in Sydney, Australia. He recently worked at Readify and the global professional services company PwC. He now works at SP Health, a global provider of weight loss web sites such at CSIRO's TotalWellBeingDiet.com and BiggestLoserClub.com.

Comments and Discussions

Great !

igetorix15-Sep-17 4:02

igetorix

15-Sep-17 4:02

Thank You ! Smile | :)

Brilliant

Member 113207582-Apr-15 4:50

Member 11320758

2-Apr-15 4:50

It's 8 years after you wrote this article and I just recently needed such a solution. Many, many thanks.

Great just what I was looking for

SteveSumner16-Mar-15 0:21

SteveSumner1

6-Mar-15 0:21

This was exactly what I was looking for, explained clearly and works a treat Smile | :)

Thanks

Ajokar-108070799-Feb-15 20:55

Ajokar-10807079

9-Feb-15 20:55

Call a Method in Another Project and Namespace Worked fine for me.
thanks a lot Smile | :)

Dynamically Invoke A Method, Given Strings with Method Name and Class Name (View)

k0718-Feb-14 2:54

k07

18-Feb-14 2:54

hii.i am kannan

can I use this Dynamically Invoke A Method, in genaric handler in asp.net ,for setting Model ,View ,Controller dynamically ??

only works with Static methods?

Member 889461427-Apr-12 4:14

Member 8894614

27-Apr-12 4:14

Converted this code to VB.NET 2010.

The author should point out that this code only works when the method is a Static method (C#) or a Shared method (VB).

I couldn't get it to work otherwise.

its good

Manish Langa18-Jan-10 19:29

Manish Langa

18-Jan-10 19:29

great...code

langa manish

good article

parthi intel5-Mar-09 1:25

parthi intel

5-Mar-09 1:25

Hi Matt,
how to do the same way for the web service and web method?
Your immediate reply would be much appreciated.

Thank you very much dude,

Nice article...but what about different parameters with different types?

Member 22902785-Jun-08 19:33

Member 2290278

5-Jun-08 19:33

how do i cater this problem?
MethodA maybe receives only 1 param of type string but MethodB receives 2 params of type string and integer..
how to solve this?

Re: Nice article...but what about different parameters with different types?

dudeserius23-Jun-08 17:12

dudeserius

23-Jun-08 17:12

I built up a class for housing little helpful functions for something such as that occasion.
The following two functions will help with this. (one is for use with static methods and one is for use with methods belonging to an instance of a class.

To Execute a Static Method:

/// <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[])

To call the above function for MethodA, you would do something like:
execStaticString("theAssembly", "theNamespace", "theClass", "MethodA", param1);

To call the above function for MethodB, you would do something like:
execStaticString("theAssembly", "theNamespace", "theClass", "MethodB", param1, param2);

To Execute a Non-Static Method:

/// <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[])

To call the above function for MethodA, you would do something like:
execExtString(this, "MethodA", "testing...1,2,3");

To call the above function for MethodB, you would do something like:
execExtString(this, "MethodB", "testing...1,2,3", 456);

----------------------
Nathan VanBuskirk
C++, C# Developer
http://Seriussoft.com

Re: Nice article...but what about different parameters with different types?

Josh1991185-Sep-08 10:30

Josh199118

5-Sep-08 10:30

Many Thanks for that piece of code

Godwin

Re: Nice article...but what about different parameters with different types?

dudeserius16-Dec-08 0:07

dudeserius

16-Dec-08 0:07

Glad to be of some help. Smile | :)

----------------------------
Nathan VanBuskirk
C++, C# Developer
http://Seriussoft.com

Re: Nice article...but what about different parameters with different types?

Genesis20019-Apr-10 9:10

Genesis2001

9-Apr-10 9:10

I was going to suggest using a params array of type object[], as well.

Also,

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

String.Format that please. Adding strings together like that would create multiple string objects whereas a String.Format would create one and simply combine then together.

Another alternative would be:

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

Or, String.Format:

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

Thanks,
-Zack

Re: Nice article...but what about different parameters with different types?

mdelgert@hotmail.com4-Jun-12 13:11

mdelgert@hotmail.com

4-Jun-12 13:11

I added the following two mods for these cases mentioned approve to share. Great example.

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

    }

}

Howabout dynamic execution of a method in the current class instance?

astanton197819-Mar-08 6:00

astanton1978

19-Mar-08 6:00

Say I have Class A and it has 2 properties (Prop1 and Prop2) and 2 methods (DoThis, DoThat).
If I have create an instance of A (objA) and then set

<br />
Prop1 = "a"<br />
Prop2 = "b"<br />

and the methods are defined as follows

<br />
Public Sub DoThis()<br />
   Prop1 += "c"<br />
End Sub<br />
<br />
Public Sub DoThat()<br />
   Prop2 += "2"<br />
End Sub<br />

If I want to have ClassA dynamically invoke DoThis() using the method you outlined (via reflection) It will create a new instance of ClassA (objB) and invoke the method. You will get a null ref exception, because objA.Prop1 will not be accessible by objB. This example is oversimplified, but think in the case of ASP.NET. If I want to access a method that is on the same page, I can, but I will not have access to any of the original pages methods and properties (all the web form control values). I can add parameters to the dynamically executed method so I have some kind of workaround, but do you know how I can best get around this?

Re: Howabout dynamic execution of a method in the current class instance?

dudeserius23-Jun-08 16:54

dudeserius

23-Jun-08 16:54

actually, the solution is not too different from his approach, but I must apologize, for I only know how to do this in c#. Hopefully it will lead you in the right direction.

//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);

---------------------
Nathan VanBuskirk
C++, C# Developer
http://Seriussoft.com

Re: Howabout dynamic execution of a method in the current class instance?

JayantaChatterjee14-Jan-13 6:10

JayantaChatterjee

14-Jan-13 6:10

My code is -:

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."

Re: Howabout dynamic execution of a method in the current class instance?

dudeserius27-Jan-13 9:43

dudeserius

27-Jan-13 9:43

I don't have an instance of visual studio on this machine, but I have a guess just from looking at your code.

You reference that the BindingFlags should contain BindingFlags.Static, but your CallMe method is an instance method. Change the method signature to the following and run that again:

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

If you intended for the method to be an instance method, then remove the BindingFlags.Static flag and add this to the 2nd from last parameter in the InvokeMember call:

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

Hope that helps Smile | :)

----------------------------
Nathan VanBuskirk
C++, C# Developer
http://Seriussoft.com

Re: Howabout dynamic execution of a method in the current class instance?

JayantaChatterjee27-Jan-13 18:41

JayantaChatterjee

27-Jan-13 18:41

thanks for your Reply....
Sir still I'm getting Error.. Frown | :(

My Code is -:

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.");
        }
}

when i run this code, The message Box displayed("The Function Not Found")...

Re: Howabout dynamic execution of a method in the current class instance?

dudeserius23-Apr-13 9:56

dudeserius

23-Apr-13 9:56

I ran your code through LinqPad, and it seems I deduced the problem. Your binding flags needs to also include instance methods

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

That should do the trick for you. I apologize for just now responding. I've been away from the internet for a while.

----------------------------
Nathan VanBuskirk
C#, VB.NET, C++, Java Developer
http://Seriussoft.com

Great

error140815-Aug-07 11:07

error1408

15-Aug-07 11:07

Thank you. That's exact what i've been searching for last week Big Grin | :-D

Very cool and useful

Mike DiRenzo7-Aug-07 6:56

Mike DiRenzo

7-Aug-07 6:56

Matt,
Thanks for this contribution. Cool article.

"In quiet and silence, the truth is made clear."

General

News

Suggestion

Question

Bug

Answer

Joke

Praise

Rant

Admin

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

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

Introduction

Simple Solution

Pass a Parameter to the Called Method

Call a Method in Another Project and Namespace

Learn More

Have a Play

History

License

Share

About the Author

Comments and Discussions

Tagged as

Stats