MethodInfo.MakeGenericMethod(Type[]) MethodInfo.MakeGenericMethod(Type[]) MethodInfo.MakeGenericMethod(Type[]) MethodInfo.MakeGenericMethod(Type[]) Method

定義

現在のジェネリック メソッド定義の型パラメーターを型の配列要素に置き換え、その結果構築されるメソッドを表す MethodInfo オブジェクトを返します。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.

public:
 virtual System::Reflection::MethodInfo ^ MakeGenericMethod(... cli::array <Type ^> ^ typeArguments);
public virtual System.Reflection.MethodInfo MakeGenericMethod (params Type[] typeArguments);
abstract member MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
Public Overridable Function MakeGenericMethod (ParamArray typeArguments As Type()) As MethodInfo

パラメーター

typeArguments
Type[]

現在のジェネリック メソッド定義の型パラメーターに置き換えられる型の配列。An array of types to be substituted for the type parameters of the current generic method definition.

戻り値

現在のジェネリック メソッド定義の型パラメーターを typeArguments の要素に置き換えることによって構築されるメソッドを表す 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.

例外

現在の MethodInfo がジェネリック メソッド定義を表していません。The current MethodInfo does not represent a generic method definition. つまり、IsGenericMethodDefinitionfalse を返します。That is, IsGenericMethodDefinition returns false.

typeArgumentsnullです。typeArguments is null.

- または --or- typeArguments のどの要素も null です。Any element of typeArguments is null.

typeArguments の要素の数が、現在のジェネリック メソッド定義の型パラメーターの数と同じではありません。The number of elements in typeArguments is not the same as the number of type parameters of the current generic method definition.

- または --or- typeArguments の要素が、現在のジェネリック メソッド定義の対応する型パラメーターに対して指定された制約を満たしていません。An element of typeArguments does not satisfy the constraints specified for the corresponding type parameter of the current generic method definition.

このメソッドはサポートされていません。This method is not supported.

次のコード例は、ジェネリックメソッドの検査MethodInfoをサポートするのプロパティとメソッドを示しています。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.

  • ジェネリックメソッドMethodInfoを表すを作成します。Creates a MethodInfo that represents the generic method.

  • ジェネリックメソッド定義のプロパティを表示します。Displays properties of the generic method definition.

  • MethodInfo型パラメーターに型引数を割り当て、結果の構築されたジェネリックメソッドを呼び出します。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.

using namespace System;
using namespace System::Reflection;

// Define a class with a generic method.
ref class Example
{
public:
    generic<typename T> static void Generic(T toDisplay)
    {
        Console::WriteLine("\r\nHere it is: {0}", toDisplay);
    }
};

void DisplayGenericMethodInfo(MethodInfo^ mi)
{
    Console::WriteLine("\r\n{0}", mi);

    Console::WriteLine("\tIs this a generic method definition? {0}", 
        mi->IsGenericMethodDefinition);

    Console::WriteLine("\tIs it a generic method? {0}", 
        mi->IsGenericMethod);

    Console::WriteLine("\tDoes it have unassigned generic parameters? {0}", 
        mi->ContainsGenericParameters);

    // If this is a generic method, display its type arguments.
    //
    if (mi->IsGenericMethod)
    {
        array<Type^>^ typeArguments = mi->GetGenericArguments();

        Console::WriteLine("\tList type arguments ({0}):", 
            typeArguments->Length);

        for each (Type^ tParam in typeArguments)
        {
            // IsGenericParameter is true only for generic type
            // parameters.
            //
            if (tParam->IsGenericParameter)
            {
                Console::WriteLine("\t\t{0}  parameter position {1}" +
                    "\n\t\t   declaring method: {2}",
                    tParam,
                    tParam->GenericParameterPosition,
                    tParam->DeclaringMethod);
            }
            else
            {
                Console::WriteLine("\t\t{0}", tParam);
            }
        }
    }
};

void main()
{
    Console::WriteLine("\r\n--- Examine a generic method.");

    // Create a Type object representing class Example, and
    // get a MethodInfo representing the generic method.
    //
    Type^ ex = Example::typeid;
    MethodInfo^ mi = ex->GetMethod("Generic");

    DisplayGenericMethodInfo(mi);

    // Assign the int type to the type parameter of the Example 
    // method.
    //
    MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid);

    DisplayGenericMethodInfo(miConstructed);

    // Invoke the method.
    array<Object^>^ args = { 42 };
    miConstructed->Invoke((Object^) 0, 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 = miConstructed->GetGenericMethodDefinition();
    Console::WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
};
        
/* 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 Example
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Examine a generic method.");

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

        DisplayGenericMethodInfo(mi);

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

        DisplayGenericMethodInfo(miConstructed);

        // Invoke the method.
        object[] args = {42};
        miConstructed.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 = miConstructed.GetGenericMethodDefinition();
        Console.WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
    }
        
    private static void DisplayGenericMethodInfo(MethodInfo mi)
    {
        Console.WriteLine("\r\n{0}", mi);

        Console.WriteLine("\tIs this a generic method definition? {0}", 
            mi.IsGenericMethodDefinition);

        Console.WriteLine("\tIs it a generic method? {0}", 
            mi.IsGenericMethod);

        Console.WriteLine("\tDoes it have unassigned 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}  parameter position {1}" +
                        "\n\t\t   declaring method: {2}",
                        tParam,
                        tParam.GenericParameterPosition,
                        tParam.DeclaringMethod);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* 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

 */
Imports System.Reflection

' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}", toDisplay)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Examine a generic method.")
        
        ' Create a Type object representing class Example, and
        ' get a MethodInfo representing the generic method.
        '
        Dim ex As Type = GetType(Example)
        Dim mi As MethodInfo = ex.GetMethod("Generic")
        
        DisplayGenericMethodInfo(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(miConstructed)

        ' Invoke the method.
        Dim args() As Object = { 42 }
        miConstructed.Invoke(Nothing, args)
        
        ' Invoke the method normally.
        Example.Generic(Of Integer)(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()
        Console.WriteLine(vbCrLf & "The definition is the same: {0}", _
            miDef Is mi)
    End Sub
      
    Private Shared Sub DisplayGenericMethodInfo(ByVal mi As MethodInfo) 
        Console.WriteLine(vbCrLf & mi.ToString())
        
        Console.WriteLine(vbTab _
            & "Is this a generic method definition? {0}", _
            mi.IsGenericMethodDefinition)

        Console.WriteLine(vbTab & "Is it a generic method? {0}", _
            mi.IsGenericMethod)

        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters? {0}", _
            mi.ContainsGenericParameters)

        ' If this is a generic method, display its type arguments.
        '
        If mi.IsGenericMethod Then
            Dim typeArguments As Type() = mi.GetGenericArguments()
            
            Console.WriteLine(vbTab & "List type arguments ({0}):", _
                typeArguments.Length)
            
            For Each tParam As Type In typeArguments
                ' IsGenericParameter is true only for generic type
                ' parameters.
                '
                If tParam.IsGenericParameter Then
                    Console.WriteLine(vbTab & vbTab _
                        & "{0}  parameter position: {1}" _
                        & vbCrLf & vbTab & vbTab _
                        & "   declaring method: {2}", _
                        tParam,  _
                        tParam.GenericParameterPosition, _
                        tParam.DeclaringMethod)
                Else
                    Console.WriteLine(vbTab & vbTab & tParam.ToString())
                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
'

注釈

メソッドを使用すると、特定の型をジェネリックメソッド定義の型パラメーターに割り当てて、特定の構築さMethodInfoれたメソッドを表すオブジェクトを作成するコードを記述できます。 MakeGenericMethodThe 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. このtrue ContainsGenericParameters オブジェクトのMethodInfoプロパティからが返された場合は、それを使用してメソッドを呼び出したり、メソッドを呼び出すデリゲートを作成したりできます。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.

MakeGenericMethodメソッドを使用して構築されたメソッドは開くことができます。つまり、一部の型引数は、外側のジェネリック型の型パラメーターにすることができます。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. たとえば、次C#の、Visual Basic、 C++コードについて考えてみます。For example, consider the following C#, Visual Basic, and C++ 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  
  
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);  
    }  
};  

Mメソッド本体には、のM型パラメーター Nと型Int32を指定して、メソッドの呼び出しが含まれています。The method body of M contains a call to method N, specifying the type parameter of M and the type Int32. プロパティIsGenericMethodDefinitionは、 false メソッドN<V,int>にを返します。The IsGenericMethodDefinition property returns false for method N<V,int>. プロパティContainsGenericParametersはをtrue返します。 N<V,int>そのため、メソッドを呼び出すことはできません。The ContainsGenericParameters property returns true, so method N<V,int> cannot be invoked.

ジェネリックメソッドに固有の用語の不変条件の一覧については、 IsGenericMethod 「」プロパティを参照してください。For a list of the invariant conditions for terms specific to generic methods, see the IsGenericMethod property. 汎用リフレクションで使用されるその他の用語の不変条件の一覧についIsGenericTypeては、プロパティを参照してください。For a list of the invariant conditions for other terms used in generic reflection, see the IsGenericType property.

適用対象

こちらもご覧ください