MethodBuilder.MakeGenericMethod Method

Microsoft Silverlight will reach end of support after October 2021. Learn more.

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)

Syntax

'Declaration
Public Overrides Function MakeGenericMethod ( _
    ParamArray typeArguments As Type() _
) As MethodInfo

public override MethodInfo MakeGenericMethod(
    params Type[] typeArguments
)

Parameters

• typeArguments
  Type: array<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.

Remarks

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.

Examples

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.

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

Imports System.Reflection
Imports System.Reflection.Emit

Class Example

   Public Shared Sub Main()

      ' Define a transient dynamic assembly (only to run, not
      ' to save) with one module and a type "Test".
      ' 
      Dim aName As AssemblyName = New AssemblyName("MyDynamic")
      Dim ab As AssemblyBuilder = _
          AppDomain.CurrentDomain.DefineDynamicAssembly( _
              aName, _
              AssemblyBuilderAccess.Run)
      Dim mb As ModuleBuilder = ab.DefineDynamicModule(aName.Name)
      Dim tb As TypeBuilder = mb.DefineType("Test")

      ' Add a Public Shared method "M" to Test, and make it a
      ' generic method with one type parameter named "T").
      '
      Dim meb As MethodBuilder = tb.DefineMethod("M", _
          MethodAttributes.Public Or MethodAttributes.Static)
      Dim typeParams() As GenericTypeParameterBuilder = _
          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(Of 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.
      Dim mi As MethodInfo = _
          meb.MakeGenericMethod(GetType(String))
      ' Note that this is actually a subclass of MethodInfo, 
      ' which has rather limited capabilities -- for
      ' example, you cannot reflect on its parameters.
   End Sub
End Class

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

Version Information

Silverlight

Supported in: 5, 4, 3

Platforms

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

See Also

Reference

MethodBuilder Class

System.Reflection.Emit Namespace

Other Resources

How to: Define a Generic Method with Reflection Emit