MethodInfo.MakeGenericMethod-Methode (System.Reflection)

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

 */