MethodBuilder::MakeGenericMethod Method (array<Type^>^)
Returns a generic method constructed from the current generic method definition using the specified generic type arguments.
Assembly: mscorlib (in mscorlib.dll)
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.
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.
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. |
using namespace System; using namespace System::Reflection; using namespace System::Reflection::Emit; void main() { // Define a transient dynamic assembly (only to run, not // to save) with one module and a type "Test". // AssemblyName^ aName = gcnew 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); array<GenericTypeParameterBuilder^>^ typeParams = meb->DefineGenericParameters(gcnew array<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(String::typeid); // Note that this is actually a subclass of MethodInfo, // which has rather limited capabilities -- for // example, you cannot reflect on its parameters. }
Available since 2.0
Silverlight
Available since 2.0
