Substitutes the elements of an array of types for the type parameters of the current generic method definition, and returns a System.Reflection.MethodInfo object representing the resulting constructed method.
Syntax
Parameters
- typeArguments
Returns
A System.Reflection.MethodInfo object that represents the constructed method formed by substituting the elements of typeArguments for the type parameters of the current generic method definition.
Exceptions
Type Reason ArgumentException The number of elements in typeArguments is not the same as the number of type parameters of the current generic method definition.
-or-
An element of typeArguments does not satisfy the constraints specified for the corresponding type parameter of the current generic method definition.
ArgumentNullException typeArguments is null.
-or-
Any element of typeArguments is null.
InvalidOperationException The current System.Reflection.MethodInfo does not represent the definition of a generic method. (That is, MethodInfo.IsGenericMethodDefinition returns false).
Remarks
The MethodInfo.MakeGenericMethod(Type[]) method allows you to write code that assigns specific types to the type parameters of a generic method definition, thus creating a System.Reflection.MethodInfo object that represents a particular constructed method. If the MethodInfo.ContainsGenericParameters property of this System.Reflection.MethodInfo object returns true, you can use it to invoke the method or to create a delegate to invoke the method.
Methods constructed with the MethodInfo.MakeGenericMethod(Type[]) method can be open, that is, some of their type arguments can be type parameters of enclosing generic types. You might use such open constructed methods when you generate dynamic assemblies. For example, consider the following C#, Visual Basic, and C++ code.
Example
class C
{
T N<T,U>(T t, U u) {...}
public V M<V>(V v)
{
return N<V,int>(v, 42);
}
}
Class C
Public Function N(Of T,U)(ByVal ta As T, ByVal ua As U) As T
...
End Function
Public Function M(Of V)(ByVal va As V ) As V
Return N(Of V, Integer)(va, 42)
End Function
End Class
ref class C
{
private:
generic <typename T, typename U> T N(T t, U u) {...}
public:
generic <typename V> V M(V v)
{
return N<V, int>(v, 42);
}
};The method body of M contains a call to method N, specifying the type parameter of M and the type int. The MethodInfo.IsGenericMethodDefinition property returns false for method N<V,int>. The MethodInfo.ContainsGenericParameters property returns true, so method N<V,int> cannot be invoked.
For a list of the invariant conditions for terms specific to generic methods, see the MethodInfo.IsGenericMethod property. For a list of the invariant conditions for other terms used in generic reflection, see the Type.IsGenericType property.
Example
The following code demonstrates the properties and methods of System.Reflection.MethodInfo that support the examination of generic methods. The example does the following:
- Defines a class that has a generic method.
- Creates a System.Reflection.MethodInfo that represents the generic method.
- Displays properties of the generic method definition.
- Binds the System.Reflection.MethodInfo to a type, and invokes it.
- Displays properties of the bound generic method.
- Retrieves the generic method definition from the bound method.
C# Example
using System;
using System.Reflection;
// Define a class with a generic method.
public class Example
{
public static void Generic<T>(T toDisplay)
{
Console.WriteLine("\nHere it is: {0}", toDisplay);
}
}
public class Test
{
public static void Main()
{
Console.WriteLine("\n--- Examine a generic method.");
// Create a Type object representing class Example, and
// get a MethodInfo representing the generic method.
//
Type ex = Type.GetType("Example");
MethodInfo mi = ex.GetMethod("Generic");
DisplayGenericMethodInfo(mi);
// Bind the type parameter of the Example method to
// type int.
//
Type[] arguments = {typeof(int)};
MethodInfo miBound = mi.MakeGenericMethod(arguments);
DisplayGenericMethodInfo(miBound);
// Invoke the method.
object[] args = {42};
miBound.Invoke(null, args);
// Invoke the method normally.
Example.Generic<int>(42);
// Get the generic type definition from the closed method,
// and show it's the same as the original definition.
//
MethodInfo miDef = miBound.GetGenericMethodDefinition();
Console.WriteLine("\nThe definition is the same: {0}",
miDef == mi);
}
private static void DisplayGenericMethodInfo(MethodInfo mi)
{
Console.WriteLine("\n{0}", mi);
Console.WriteLine("\tIs this a generic method definition? {0}",
mi.IsGenericMethodDefinition);
Console.WriteLine("\tDoes it have generic arguments? {0}",
mi.IsGenericMethod);
Console.WriteLine("\tDoes it have unbound generic parameters? {0}",
mi.ContainsGenericParameters);
// If this is a generic method, display its type arguments.
//
if (mi.IsGenericMethod)
{
Type[] typeArguments = mi.GetGenericArguments();
Console.WriteLine("\tList type arguments ({0}):",
typeArguments.Length);
foreach (Type tParam in typeArguments)
{
// IsGenericParameter is true only for generic type
// parameters.
//
if (tParam.IsGenericParameter)
{
Console.WriteLine("\t\t{0} (unbound - parameter position {1})",
tParam,
tParam.GenericParameterPosition);
}
else
{
Console.WriteLine("\t\t{0}", tParam);
}
}
}
else
{
Console.WriteLine("\tThis is not a generic method.");
}
}
}
/* This example produces the following output:
--- Examine a generic method.
Void Generic[T](T)
Is this a generic method definition? True
Does it have generic arguments? True
Does it have unbound generic parameters? True
List type arguments (1):
T (unbound - parameter position 0)
Void Generic[Int32](Int32)
Is this a generic method definition? False
Does it have generic arguments? True
Does it have unbound generic parameters? False
List type arguments (1):
System.Int32
Here it is: 42
Here it is: 42
The definition is the same: True
*/
Requirements
Assembly: mscorlib (in mscorlib.dll)
Assembly Versions: 2.0.0.0, 4.0.0.0
Since: .NET 2.0