Export (0) Print
Expand All

MethodBuilder.MakeGenericMethod Method

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

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


Silverlight

Supported in: 5, 4, 3

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.

Community Additions

ADD
Show:
© 2014 Microsoft