MethodBuilder.MakeGenericMethod Method (Type[])

 

Returns a generic method constructed from the current generic method definition using the specified generic type arguments.

Namespace:   System.Reflection.Emit
Assembly:  mscorlib (in mscorlib.dll)

public override MethodInfo MakeGenericMethod(
	params Type[] typeArguments
)

Parameters

typeArguments
Type: System.Type[]

An array of Type objects that represent the type arguments for the generic method.

Return Value

Type: System.Reflection.MethodInfo

A MethodInfo representing the generic method constructed from the current generic method definition using the specified generic type arguments.

When you are emitting dynamic code, you might need to emit a call to a method constructed from the generic method definition represented by a MethodBuilder, before the enclosing type has been completed. You can use the MakeGenericMethod method to create a MethodInfo for such a constructed method, and use the MethodInfo in the emitted call.

The following code example creates a constructed method from an incomplete generic method definition in an incomplete type.

The example creates a transient assembly and module with a single type, adds a method M, and makes the method generic by adding a type parameter T using the DefineGenericParameters method. The type parameter is used as the type of the method's parameter, and also as its return type. The generic method definition is not given a body, and the enclosing type is not completed. The MakeGenericMethod method is then used to make the constructed method M<String> (M(Of String) in Visual Basic). The example code has no output, because the subclass of MethodInfo returned by the MakeGenericMethod method does not allow reflection over its parameters.

System_CAPS_noteNote

For another code example that uses MakeGenericMethod, see DefineGenericParameters. MakeGenericMethod is also used extensively when emitting code that uses generic types. See How to: Define a Generic Method with Reflection Emit.

using System;
using System.Reflection;
using System.Reflection.Emit;

class Example
{
    public static void Main()
    {
        // Define a transient dynamic assembly (only to run, not
        // to save) with one module and a type "Test".
        // 
        AssemblyName aName = new AssemblyName("MyDynamic");
        AssemblyBuilder ab = 
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                aName, 
                AssemblyBuilderAccess.Run);
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
        TypeBuilder tb = mb.DefineType("Test");

        // Add a public static method "M" to Test, and make it a
        // generic method with one type parameter named "T").
        //
        MethodBuilder meb = tb.DefineMethod("M", 
            MethodAttributes.Public | MethodAttributes.Static);
        GenericTypeParameterBuilder[] typeParams = 
            meb.DefineGenericParameters(new string[] { "T" });

        // Give the method one parameter, of type T, and a 
        // return type of T.
        meb.SetParameters(typeParams);
        meb.SetReturnType(typeParams[0]);

        // Create a MethodInfo for M<string>, which can be used in
        // emitted code. This is possible even though the method
        // does not yet have a body, and the enclosing type is not
        // created.
        MethodInfo mi = meb.MakeGenericMethod(typeof(string));
        // Note that this is actually a subclass of MethodInfo, 
        // which has rather limited capabilities -- for
        // example, you cannot reflect on its parameters.
    }
}

.NET Framework
Available since 2.0
Silverlight
Available since 2.0
Return to top
Show: