MethodInfo.MakeGenericMethod(Type[]) Metode

Definisi

Ruang nama:

System.Reflection

Rakitan:

netstandard.dll, System.Runtime.dll

Sumber:

MethodInfo.cs

Mengganti elemen array jenis untuk parameter jenis definisi metode generik saat ini, dan mengembalikan objek yang MethodInfo mewakili metode yang dihasilkan.

public:
 virtual System::Reflection::MethodInfo ^ MakeGenericMethod(... cli::array <Type ^> ^ typeArguments);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
public virtual System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")>]
[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")>]
abstract member MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo

Public Overridable Function MakeGenericMethod (ParamArray typeArguments As Type()) As MethodInfo

Parameter

typeArguments

Type[]

Array jenis yang akan digantikan untuk parameter jenis definisi metode generik saat ini.

Mengembalikan

MethodInfo

Objek MethodInfo yang mewakili metode yang dibangun yang dibentuk dengan mengganti elemen typeArguments untuk parameter jenis definisi metode generik saat ini.

Atribut

RequiresDynamicCodeAttribute RequiresUnreferencedCodeAttribute

Pengecualian

InvalidOperationException

Saat ini MethodInfo tidak mewakili definisi metode generik. Artinya, IsGenericMethodDefinition mengembalikan false.

ArgumentNullException

typeArguments adalah null.

-atau-

Elemen apa pun adalah typeArgumentsnull.

ArgumentException

Jumlah elemen di typeArguments tidak sama dengan jumlah parameter jenis dari definisi metode generik saat ini.

-atau-

Elemen typeArguments tidak memenuhi batasan yang ditentukan untuk parameter jenis yang sesuai dari definisi metode generik saat ini.

NotSupportedException

Metode ini tidak didukung.

Contoh

Contoh kode berikut menunjukkan properti dan metode MethodInfo yang mendukung pemeriksaan metode generik. Contohnya melakukan hal berikut:

• Mendefinisikan kelas yang memiliki metode generik.
• MethodInfo Membuat yang mewakili metode generik.
• Menampilkan properti definisi metode generik.
• Menetapkan argumen jenis ke parameter MethodInfojenis , dan memanggil metode generik yang dibuat yang dihasilkan.
• Menampilkan properti metode generik yang dibangun.
• Mengambil definisi metode generik dari metode yang dibangun dan membandingkannya dengan definisi asli.

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
'

Keterangan

Metode ini MakeGenericMethod memungkinkan Anda menulis kode yang menetapkan jenis tertentu ke parameter jenis definisi metode generik, sehingga membuat MethodInfo objek yang mewakili metode yang dibangun tertentu. ContainsGenericParameters Jika properti objek ini MethodInfo mengembalikan true, Anda dapat menggunakannya untuk memanggil metode atau untuk membuat delegasi untuk memanggil metode .

Metode yang dibangun dengan MakeGenericMethod metode dapat terbuka, yaitu, beberapa argumen jenisnya dapat menjadi parameter jenis dari jenis generik yang diapit. Anda dapat menggunakan metode yang dibangun terbuka seperti itu saat Anda menghasilkan rakitan dinamis. Sebagai contoh, perhatikan kode berikut.

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

Isi M metode berisi panggilan ke metode N, menentukan parameter M jenis dan jenis Int32. Properti IsGenericMethodDefinition mengembalikan false untuk metode N<V,int>. Properti ContainsGenericParameters mengembalikan true, sehingga metode N<V,int> tidak dapat dipanggil.

Untuk daftar ketentuan invarian untuk istilah khusus untuk metode generik, lihat IsGenericMethod properti . Untuk daftar kondisi invarian untuk istilah lain yang digunakan dalam refleksi generik, lihat IsGenericType properti .

Lihat juga

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• Refleksi dan Jenis Generik
• Pengantar Generik (Panduan Pemrograman C#)