C# GetMethod

Reflection

GetMethod references methods with only a string name. With it we call a method whose name equals this string. This involves the System.Reflection namespace and the MethodInfo type found there.

Example

Before we begin, please notice the System.Reflection namespace. Reflection here refers to how C# programs can look inside themselves and then act upon their metadata programmatically.

Next:We want to call the Inform static method by using the string "Inform" and we want to call it twice with different parameters.

Static Method
C# program that uses GetMethod

using System;
using System.Reflection;

static class Methods
{
    public static void Inform(string parameter)
    {
	Console.WriteLine("Inform:parameter={0}", parameter);
    }
}

class Program
{
    static void Main()
    {
	// Name of the method we want to call.
	string name = "Inform";

	// Call it with each of these parameters.
	string[] parameters = { "Sam", "Perls" };

	// Get MethodInfo.
	Type type = typeof(Methods);
	MethodInfo info = type.GetMethod(name);

	// Loop over parameters.
	foreach (string parameter in parameters)
	{
	    info.Invoke(null, new object[] { parameter });
	}
    }
}

Output

Inform:parameter=Sam
Inform:parameter=Perls
Typeof operator

In this example, the expression typeof(Methods) references the Methods class and returns Type pointer. We next call the instance method GetMethod on the type instance. This returns a MethodInfo instance or null if no method was located.

TypeForeach loop construct

Next, in the foreach loop, we call Invoke repeatedly. The first argument to Invoke is null. This is because the target method is static and has no instance expression. The second argument is wrapped in an object array.

ForeachObject Array

Note:You must do this even if there is only one required parameter. It is not optional.

MethodInfo Invoke

Summary

C# programming language

It is possible to call methods by their names in the C# language. Using reflection, you can create interesting abilities in your programs, such as query languages that can reference arbitrary methods in the metadata.

Tip:This is best for situations where performance is not critical. It is ideal for less frequently used code.


C#: .NET: Reflection