共用方式為

  • 發行項

MethodInfo.MakeGenericMethod Method

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

Substitutes the elements of an array of types for the type parameters of the current generic method definition, and returns a MethodInfo object representing the resulting constructed method.

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

Syntax

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

public virtual MethodInfo MakeGenericMethod(
    params Type[] typeArguments
)

Parameters

  • typeArguments
    Type: array<System.Type[]
    An array of types to be substituted for the type parameters of the current generic method definition.

Return Value

Type: System.Reflection.MethodInfo
A 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

Exception Condition
InvalidOperationException

The current MethodInfo does not represent a generic method definition. That is, IsGenericMethodDefinition returns false.
ArgumentNullException

typeArguments is nulla null reference (Nothing in Visual Basic).

-or-

Any element of typeArguments is nulla null reference (Nothing in Visual Basic).
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.
NotSupportedException

This method is not supported.

Remarks

The MakeGenericMethod method allows you to write code that assigns specific types to the type parameters of a generic method definition, thus creating a MethodInfo object that represents a particular constructed method. If the ContainsGenericParameters property of this 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 MakeGenericMethod 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# and Visual Basic code.

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

The method body of M contains a call to method N, specifying the type parameter of M and the type Int32. The IsGenericMethodDefinition property returns false for method N<V,int>. The 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 IsGenericMethod property. For a list of the invariant conditions for other terms used in generic reflection, see the IsGenericType property.

Platform Notes

Silverlight for Windows Phone Silverlight for Windows Phone

 MakeGenericMethod is present but not supported in Silverlight for Windows Phone.

Examples

The following code example demonstrates the properties and methods of MethodInfo that support the examination of generic methods. The example does the following:

  • Defines a class that has a generic method.

  • Creates a MethodInfo that represents the generic method.

  • Displays properties of the generic method definition.

  • Assigns type arguments to the type parameters of the MethodInfo, and invokes the resulting constructed generic method.

  • Displays properties of the constructed generic method.

  • Retrieves the generic method definition from the constructed method and compares it to the original definition.

NoteNote:

To run this example, see Building Examples That Use a Demo Method and a TextBlock Control.

 
Imports System.Reflection

' Define a class with a generic method.
Public Class Test
   Public Shared Sub Generic(Of T)(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal toDisplay As T)
      outputBlock.Text &= String.Format(vbCrLf & "Here it is: {0}", toDisplay) & vbCrLf
   End Sub
End Class

Public Class Example
   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      outputBlock.Text &= vbCrLf & "--- Examine a generic method." & vbCrLf

      ' Create a Type object representing class Test, and
      ' get a MethodInfo representing the generic method.
      '
      Dim ex As Type = GetType(Test)
      Dim mi As MethodInfo = ex.GetMethod("Generic")

      DisplayGenericMethodInfo(outputBlock, mi)

      ' Assign the Integer type to the type parameter of the Example 
      ' method.
      '
      Dim arguments() As Type = {GetType(Integer)}
      Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)

      DisplayGenericMethodInfo(outputBlock, miConstructed)

      ' Invoke the method.
      Dim args() As Object = {outputBlock, 42}
      miConstructed.Invoke(Nothing, args)

      ' Invoke the method normally.
      Test.Generic(Of Integer)(outputBlock, 42)

      ' Get the generic type definition from the constructed method,
      ' and show that it's the same as the original definition.
      '
      Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
      outputBlock.Text &= String.Format(vbCrLf & "The definition is the same: {0}", _
          miDef Is mi) & vbCrLf
   End Sub 'Main

   Private Shared Sub DisplayGenericMethodInfo(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal mi As MethodInfo)
      outputBlock.Text &= vbCrLf & mi.ToString() & vbCrLf

      outputBlock.Text &= String.Format(vbTab _
          & "Is this a generic method definition? {0}", _
          mi.IsGenericMethodDefinition) & vbCrLf

      outputBlock.Text &= String.Format(vbTab & "Is it a generic method? {0}", _
          mi.IsGenericMethod) & vbCrLf

      outputBlock.Text &= String.Format(vbTab _
          & "Does it have unassigned generic parameters? {0}", _
          mi.ContainsGenericParameters) & vbCrLf

      ' If this is a generic method, display its type arguments.
      '
      If mi.IsGenericMethod Then
         Dim typeArguments As Type() = mi.GetGenericArguments()

         outputBlock.Text &= String.Format(vbTab & "List type arguments ({0}) & vbCrLf:", _
             typeArguments.Length)

         For Each tParam As Type In typeArguments
            ' IsGenericParameter is true only for generic type
            ' parameters.
            '
            If tParam.IsGenericParameter Then
               outputBlock.Text &= String.Format(vbTab & vbTab _
                   & "{0}  parameter position: {1}" _
                   & vbCrLf & vbTab & vbTab _
                   & "   declaring method: {2}", _
                   tParam, _
                   tParam.GenericParameterPosition, _
                   tParam.DeclaringMethod) & vbCrLf
            Else
               outputBlock.Text &= vbTab & vbTab & tParam.ToString() & vbCrLf
            End If
         Next tParam
      End If
   End Sub
End Class

' This example produces the following output:
'
'--- Examine a generic method.
'
'Void Generic[T](T)
'        Is this a generic method definition? True
'        Is it a generic method? True
'        Does it have unassigned generic parameters? True
'        List type arguments (1):
'                T  parameter position: 0
'                   declaring method: Void Generic[T](T)
'
'Void Generic[Int32](Int32)
'        Is this a generic method definition? False
'        Is it a generic method? True
'        Does it have unassigned generic parameters? False
'        List type arguments (1):
'                System.Int32
'
'Here it is: 42
'
'Here it is: 42
'
'The definition is the same: True
'

using System;
using System.Reflection;

// Define a class with a generic method.
public class Test
{
   public static void Generic<T>(System.Windows.Controls.TextBlock outputBlock, T toDisplay)
   {
      outputBlock.Text += String.Format("\r\nHere it is: {0}", toDisplay) + "\n";
   }
}

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      outputBlock.Text += "\r\n--- Examine a generic method." + "\n";

      // Create a Type object representing class Test, and
      // get a MethodInfo representing the generic method.
      //
      Type ex = typeof(Test);
      MethodInfo mi = ex.GetMethod("Generic");

      DisplayGenericMethodInfo(outputBlock, mi);

      // Assign the int type to the type parameter of the Example 
      // method.
      //
      MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

      DisplayGenericMethodInfo(outputBlock, miConstructed);

      // Invoke the method.
      object[] args = {outputBlock, 42};
      miConstructed.Invoke(null, args);

      // Invoke the method normally.
      Test.Generic<int>(outputBlock, 42);

      // Get the generic type definition from the closed method,
      // and show it's the same as the original definition.
      //
      MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
      outputBlock.Text += String.Format("\r\nThe definition is the same: {0}",
          miDef == mi) + "\n";
   }

   private static void DisplayGenericMethodInfo(System.Windows.Controls.TextBlock outputBlock, MethodInfo mi)
   {
      outputBlock.Text += String.Format("\r\n{0}", mi) + "\n";

      outputBlock.Text += String.Format("\tIs this a generic method definition? {0}",
          mi.IsGenericMethodDefinition) + "\n";

      outputBlock.Text += String.Format("\tIs it a generic method? {0}",
          mi.IsGenericMethod) + "\n";

      outputBlock.Text += String.Format("\tDoes it have unassigned generic parameters? {0}",
          mi.ContainsGenericParameters) + "\n";

      // If this is a generic method, display its type arguments.
      //
      if (mi.IsGenericMethod)
      {
         Type[] typeArguments = mi.GetGenericArguments();

         outputBlock.Text += String.Format("\tList type arguments ({0}):",
             typeArguments.Length) + "\n";

         foreach (Type tParam in typeArguments)
         {
            // IsGenericParameter is true only for generic type
            // parameters.
            //
            if (tParam.IsGenericParameter)
            {
               outputBlock.Text += String.Format("\t\t{0}  parameter position {1}" +
                   "\n\t\t   declaring method: {2}",
                   tParam,
                   tParam.GenericParameterPosition,
                   tParam.DeclaringMethod) + "\n";
            }
            else
            {
               outputBlock.Text += String.Format("\t\t{0}", tParam) + "\n";
            }
         }
      }
   }
}

/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */

Version Information

Silverlight

Supported in: 5, 4, 3

Silverlight for Windows Phone

Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0

XNA Framework

Supported in: Xbox 360, Windows Phone OS 7.0

Platforms

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