DynamicMethod Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.Lightweight.dll

Zdroj:

DynamicMethod.cs

Definuje a představuje dynamickou metodu, kterou lze zkompilovat, spustit a zahodit. Zahozené metody jsou k dispozici pro uvolňování paměti.

public ref class DynamicMethod sealed : System::Reflection::MethodInfo

public sealed class DynamicMethod : System.Reflection.MethodInfo

type DynamicMethod = class
    inherit MethodInfo

Public NotInheritable Class DynamicMethod
Inherits MethodInfo

Dědičnost

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Příklady

Následující příklad kódu vytvoří dynamickou metodu, která přebírá dva parametry. Příklad vygeneruje jednoduchý text funkce, který vytiskne první parametr do konzoly a v příkladu se jako návratová hodnota metody použije druhý parametr. Příklad dokončí metodu vytvořením delegáta, vyvolá delegáta s různými parametry a nakonec vyvolá dynamickou metodu Invoke .

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method.
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello",
            typeof(int),
            helloArgs,
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine",
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi =
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and value-type arguments
        // must be boxed.
        object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
        Console.WriteLine("hello.Invoke returned: " + objRet);

        Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}",
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Globalization

Public Class Test
    ' Declare a delegate type that can be used to execute the completed
    ' dynamic method. 
    Private Delegate Function HelloDelegate(ByVal msg As String, _
        ByVal ret As Integer) As Integer

    Public Shared Sub Main()
        ' Create an array that specifies the types of the parameters
        ' of the dynamic method. This dynamic method has a String
        ' parameter and an Integer parameter.
        Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

        ' Create a dynamic method with the name "Hello", a return type
        ' of Integer, and two parameters whose types are specified by
        ' the array helloArgs. Create the method in the module that
        ' defines the String class.
        Dim hello As New DynamicMethod("Hello", _
            GetType(Integer), _
            helloArgs, _
            GetType(String).Module)

        ' Create an array that specifies the parameter types of the
        ' overload of Console.WriteLine to be used in Hello.
        Dim writeStringArgs() As Type = {GetType(String)}
        ' Get the overload of Console.WriteLine that has one
        ' String parameter.
        Dim writeString As MethodInfo = GetType(Console). _
            GetMethod("WriteLine", writeStringArgs) 

        ' Get an ILGenerator and emit a body for the dynamic method,
        ' using a stream size larger than the IL that will be
        ' emitted.
        Dim il As ILGenerator = hello.GetILGenerator(256)
        ' Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0)
        ' Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, Nothing)
        ' The Hello method returns the value of the second argument;
        ' to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1)
        il.Emit(OpCodes.Ret)

        ' Add parameter information to the dynamic method. (This is not
        ' necessary, but can be useful for debugging.) For each parameter,
        ' identified by position, supply the parameter attributes and a 
        ' parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message")
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn")

        ' Create a delegate that represents the dynamic method. This
        ' action completes the method. Any further attempts to
        ' change the method are ignored.
    Dim hi As HelloDelegate = _
            CType(hello.CreateDelegate(GetType(HelloDelegate)), HelloDelegate)

        ' Use the delegate to execute the dynamic method.
        Console.WriteLine(vbCrLf & "Use the delegate to execute the dynamic method:")
        Dim retval As Integer = hi(vbCrLf & "Hello, World!", 42)
        Console.WriteLine("Invoking delegate hi(""Hello, World!"", 42) returned: " _
            & retval & ".")

        ' Execute it again, with different arguments.
        retval = hi(vbCrLf & "Hi, Mom!", 5280)
        Console.WriteLine("Invoking delegate hi(""Hi, Mom!"", 5280) returned: " _
            & retval & ".")

        Console.WriteLine(vbCrLf & "Use the Invoke method to execute the dynamic method:")
        ' Create an array of arguments to use with the Invoke method.
        Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
        ' Invoke the dynamic method using the arguments. This is much
        ' slower than using the delegate, because you must create an
        ' array to contain the arguments, and value-type arguments
        ' must be boxed.
        Dim objRet As Object = hello.Invoke(Nothing, _
            BindingFlags.ExactBinding, Nothing, invokeArgs, _
            New CultureInfo("en-us"))
        Console.WriteLine("hello.Invoke returned: {0}", objRet)

        Console.WriteLine(vbCrLf & _
            " ----- Display information about the dynamic method -----")
        ' Display MethodAttributes for the dynamic method, set when 
        ' the dynamic method was created.
        Console.WriteLine(vbCrLf & "Method Attributes: {0}", _
            hello.Attributes)

        ' Display the calling convention of the dynamic method, set when the 
        ' dynamic method was created.
        Console.WriteLine(vbCrLf & "Calling convention: {0}", _ 
            hello.CallingConvention)

        ' Display the declaring type, which is always Nothing for dynamic
        ' methods.
        If hello.DeclaringType Is Nothing Then
            Console.WriteLine(vbCrLf & "DeclaringType is always Nothing for dynamic methods.")
        Else
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType)
        End If

        ' Display the default value for InitLocals.
        If hello.InitLocals Then
            Console.Write(vbCrLf & "This method contains verifiable code.")
        Else
            Console.Write(vbCrLf & "This method contains unverifiable code.")
        End If
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals)

        ' Display the module specified when the dynamic method was created.
        Console.WriteLine(vbCrLf & "Module: {0}", hello.Module)

        ' Display the name specified when the dynamic method was created.
        ' Note that the name can be blank.
        Console.WriteLine(vbCrLf & "Name: {0}", hello.Name)

        ' For dynamic methods, the reflected type is always Nothing.
        If hello.ReflectedType Is Nothing Then
            Console.WriteLine(vbCrLf & "ReflectedType is Nothing.")
        Else
            Console.WriteLine(vbCrLf & "ReflectedType: {0}", _
                hello.ReflectedType)
        End If

        If hello.ReturnParameter Is Nothing Then
            Console.WriteLine(vbCrLf & "Method has no return parameter.")
        Else
            Console.WriteLine(vbCrLf & "Return parameter: {0}", _
                hello.ReturnParameter)
        End If

        ' If the method has no return type, ReturnType is System.Void.
        Console.WriteLine(vbCrLf & "Return type: {0}", hello.ReturnType)           

        ' ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        ' that can be used to enumerate the custom attributes of the
        ' return value. At present, there is no way to set such custom
        ' attributes, so the list is empty.
        If hello.ReturnType Is GetType(System.Void) Then
            Console.WriteLine("The method has no return type.")
        Else
            Dim caProvider As ICustomAttributeProvider = _
                hello.ReturnTypeCustomAttributes
            Dim returnAttributes() As Object = _
                caProvider.GetCustomAttributes(True)
            If returnAttributes.Length = 0 Then
                Console.WriteLine(vbCrLf _
                    & "The return type has no custom attributes.")
            Else
                Console.WriteLine(vbCrLf _
                    & "The return type has the following custom attributes:")
                For Each attr As Object In returnAttributes
                    Console.WriteLine(vbTab & attr.ToString())
                Next attr
            End If
        End If

        Console.WriteLine(vbCrLf & "ToString: " & hello.ToString())

        ' Display parameter information.
        Dim parameters() As ParameterInfo = hello.GetParameters()
        Console.WriteLine(vbCrLf & "Parameters: name, type, ParameterAttributes")
        For Each p As ParameterInfo In parameters
            Console.WriteLine(vbTab & "{0}, {1}, {2}", _ 
                p.Name, p.ParameterType, p.Attributes)
        Next p
    End Sub
End Class

' This code example produces the following output:
'
'Use the delegate to execute the dynamic method:
'
'Hello, World!
'Invoking delegate hi("Hello, World!", 42) returned: 42.
'
'Hi, Mom!
'Invoking delegate hi("Hi, Mom!", 5280) returned: 5280.
'
'Use the Invoke method to execute the dynamic method:
'
'Hello, World!
'hello.Invoke returned: 42
'
' ----- Display information about the dynamic method -----
'
'Method Attributes: PrivateScope, Public, Static
'
'Calling convention: Standard
'
'DeclaringType is always Nothing for dynamic methods.
'
'This method contains verifiable code. (InitLocals = True)
'
'Module: CommonLanguageRuntimeLibrary
'
'Name: Hello
'
'ReflectedType is Nothing.
'
'Method has no return parameter.
'
'Return type: System.Int32
'
'The return type has no custom attributes.
'
'ToString: Int32 Hello(System.String, Int32)
'
'Parameters: name, type, ParameterAttributes
'        message, System.String, In
'        valueToReturn, System.Int32, In

Poznámky

Další informace o tomto rozhraní API naleznete v tématu Doplňkové poznámky k rozhraní API pro DynamicMethod.

Konstruktory

Name	Description
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Vytvoří dynamickou metodu, která je globální pro modul, určuje název metody, atributy, konvenci volání, návratový typ, typy parametrů, modul a zda kontroly viditelnosti za běhu (JIT) by měly být vynechány pro typy a členy, ke kterým přistupuje Microsoft zprostředkující jazyk (MSIL) dynamické metody.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Vytvoří dynamickou metodu, určí název metody, atributy, konvenci volání, návratový typ, typy parametrů, typ, se kterým je dynamická metoda logicky přidružená, a zda kontroly viditelnosti za běhu (JIT) by měly být vynechány pro typy a členy, ke kterým přistupuje Microsoft zprostředkující jazyk (MSIL) dynamické metody.
DynamicMethod(String, Type, Type[], Boolean)	Inicializuje anonymně hostovanou dynamickou metodu, zadá název metody, návratový typ, typy parametrů a zda by měly být kontroly viditelnosti za běhu (JIT) vynechány pro typy a členy, ke které přistupuje Microsoft zprostředkující jazyk (MSIL) dynamické metody.
DynamicMethod(String, Type, Type[], Module, Boolean)	Vytvoří dynamickou metodu, která je globální pro modul, určuje název metody, návratový typ, typy parametrů, modul a zda by měly být kontroly viditelnosti za běhu (JIT) vynechány pro typy a členy, ke kterým přistupuje Microsoft zprostředkující jazyk (MSIL) dynamické metody.
DynamicMethod(String, Type, Type[], Module)	Vytvoří dynamickou metodu, která je globální pro modul, určuje název metody, návratový typ, typy parametrů a modul.
DynamicMethod(String, Type, Type[], Type, Boolean)	Vytvoří dynamickou metodu, určí název metody, návratový typ, typy parametrů, typ, se kterým je dynamická metoda logicky přidružená, a zda kontroly viditelnosti za běhu (JIT) by měly být vynechány pro typy a členy, ke kterým přistupuje Microsoft zprostředkující jazyk (MSIL) dynamické metody.
DynamicMethod(String, Type, Type[], Type)	Vytvoří dynamickou metodu, určuje název metody, návratový typ, typy parametrů a typ, se kterým je dynamická metoda logicky přidružena.
DynamicMethod(String, Type, Type[])	Inicializuje anonymně hostované dynamické metody, určuje název metody, návratový typ a typy parametrů.

Vlastnosti

Name	Description
Attributes	Získá atributy zadané při vytvoření dynamické metody.
CallingConvention	Získá volání konvence zadané při vytvoření dynamické metody.
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaringType	Získá typ, který deklaruje metodu, což je vždy null pro dynamické metody.
InitLocals	Získá nebo nastaví hodnotu určující, zda místní proměnné v metodě jsou inicializovány nulou.
IsAbstract	Získá hodnotu určující, zda metoda je abstraktní. (Zděděno od MethodBase)
IsAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána Assembly; to znamená, že metoda nebo konstruktor je viditelná nejvýše pro jiné typy ve stejném sestavení a není viditelná pro odvozené typy mimo sestavení. (Zděděno od MethodBase)
IsCollectible	Získá hodnotu, která označuje, zda tento MemberInfo objekt odkazuje na jedno nebo více sestavení uložených v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsConstructedGenericMethod	Definuje a představuje dynamickou metodu, kterou lze zkompilovat, spustit a zahodit. Zahozené metody jsou k dispozici pro uvolňování paměti. (Zděděno od MethodBase)
IsConstructor	Získá hodnotu určující, zda metoda je konstruktor. (Zděděno od MethodBase)
IsFamily	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána Family; to znamená, že metoda nebo konstruktor je viditelná pouze v rámci své třídy a odvozené třídy. (Zděděno od MethodBase)
IsFamilyAndAssembly	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána FamANDAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami, ale pouze pokud jsou ve stejném sestavení. (Zděděno od MethodBase)
IsFamilyOrAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána FamORAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami bez ohledu na to, kde jsou, a třídami ve stejném sestavení. (Zděděno od MethodBase)
IsFinal	Získá hodnotu určující, zda tato metoda je final. (Zděděno od MethodBase)
IsHideBySig	Získá hodnotu určující, zda je v odvozené třídě skrytý pouze člen stejného typu s přesně stejným podpisem. (Zděděno od MethodBase)
IsPrivate	Získá hodnotu určující, zda je tento člen soukromý. (Zděděno od MethodBase)
IsPublic	Získá hodnotu určující, zda je to veřejná metoda. (Zděděno od MethodBase)
IsSecurityCritical	Získá hodnotu, která označuje, zda aktuální dynamická metoda je kritická zabezpečení nebo zabezpečení-bezpečné-kritické, a proto může provádět kritické operace.
IsSecuritySafeCritical	Získá hodnotu, která označuje, zda aktuální dynamická metoda je zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti; to znamená, jestli může provádět kritické operace a může k němu přistupovat transparentní kód.
IsSecurityTransparent	Získá hodnotu, která označuje, zda aktuální dynamická metoda je transparentní na aktuální úrovni důvěryhodnosti, a proto nemůže provádět kritické operace.
IsSpecialName	Získá hodnotu označující, zda tato metoda má speciální název. (Zděděno od MethodBase)
IsStatic	Získá hodnotu určující, zda metoda je static. (Zděděno od MethodBase)
IsVirtual	Získá hodnotu určující, zda metoda je virtual. (Zděděno od MethodBase)
MemberType	MemberTypes Získá hodnotu označující, že tento člen je metoda. (Zděděno od MethodInfo)
MetadataToken	Získá hodnotu, která identifikuje prvek metadat. (Zděděno od MemberInfo)
MethodHandle	Nepodporuje se u dynamických metod.
MethodImplementationFlags	Získá MethodImplAttributes příznaky, které určují atributy implementace metody. (Zděděno od MethodBase)
Module	Získá modul, se kterým je dynamická metoda logicky přidružena.
Name	Získá název dynamické metody.
ReflectedType	Získá třídu, která byla použita v reflexi k získání metody.
ReturnParameter	Získá návratový parametr dynamické metody.
ReturnType	Získá typ návratové hodnoty pro dynamickou metodu.
ReturnTypeCustomAttributes	Získá vlastní atributy návratového typu pro dynamickou metodu.

Metody

Name	Description
CreateDelegate(Type, Object)	Dokončí dynamickou metodu a vytvoří delegáta, který lze použít ke spuštění, určení typu delegáta a objektu, ke kterému je delegát vázán.
CreateDelegate(Type)	Dokončí dynamickou metodu a vytvoří delegáta, který lze použít ke spuštění.
CreateDelegate<T>()	Vytvoří delegáta typu T z této metody. (Zděděno od MethodInfo)
CreateDelegate<T>(Object)	Vytvoří delegáta typu T se zadaným cílem z této metody. (Zděděno od MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	Definuje parametr dynamické metody.
Equals(Object)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému objektu. (Zděděno od MethodInfo)
GetBaseDefinition()	Vrátí základní implementaci metody.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy definované pro metodu.
GetCustomAttributes(Type, Boolean)	Vrátí vlastní atributy zadaného typu, které byly použity pro metodu.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena. (Zděděno od MemberInfo)
GetDynamicILInfo()	Vrátí objekt DynamicILInfo, který lze použít k vygenerování těla metody z tokenů metadat, oborů a datových proudů Microsoft zprostředkujícího jazyka (MSIL).
GetGenericArguments()	Vrátí pole Type objektů, které představují argumenty typu obecné metody nebo parametry typu definice obecné metody. (Zděděno od MethodInfo)
GetGenericMethodDefinition()	MethodInfo Vrátí objekt, který představuje obecnou definici metody, ze které lze vytvořit aktuální metodu. (Zděděno od MethodInfo)
GetHashCode()	Vrátí kód hash pro tuto instanci. (Zděděno od MethodInfo)
GetILGenerator()	Vrátí generátor Microsoft zprostředkujícího jazyka (MSIL) pro metodu s výchozí velikostí datového proudu MSIL o velikosti 64 bajtů.
GetILGenerator(Int32)	Vrátí generátor Microsoft zprostředkujícího jazyka (MSIL) pro metodu se zadanou velikostí datového proudu JAZYKA MSIL.
GetMethodBody()	Při přepsání v odvozené třídě získá MethodBody objekt, který poskytuje přístup k msIL stream, místní proměnné a výjimky pro aktuální metodu. (Zděděno od MethodBase)
GetMethodImplementationFlags()	Vrátí příznaky implementace pro metodu.
GetParameters()	Vrátí parametry dynamické metody.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a představuje dynamickou metodu, kterou lze zkompilovat, spustit a zahodit. Zahozené metody jsou k dispozici pro uvolňování paměti. (Zděděno od MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Vyvolá dynamickou metodu pomocí zadaných parametrů v rámci omezení zadaného pořadače se zadanými informacemi jazykové verze.
IsDefined(Type, Boolean)	Určuje, zda je definován zadaný typ vlastního atributu.
MakeGenericMethod(Type[])	Nahradí prvky pole typů parametry typu aktuální definice obecné metody a vrátí MethodInfo objekt představující výslednou konstruovanou metodu. (Zděděno od MethodInfo)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vrátí podpis metody reprezentované jako řetězec.

Metody rozšíření

Name	Description
GetBaseDefinition(MethodInfo)	Definuje a představuje dynamickou metodu, kterou lze zkompilovat, spustit a zahodit. Zahozené metody jsou k dispozici pro uvolňování paměti.
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které se použijí na zadaného člena, a volitelně zkontroluje předky daného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které se použijí na zadaný člen.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetMetadataToken(MemberInfo)	Získá token metadat pro daného člena, pokud je k dispozici.
GetRuntimeBaseDefinition(MethodInfo)	Načte objekt, který představuje zadanou metodu pro přímou nebo nepřímou základní třídu, kde byla metoda poprvé deklarována.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která určuje, zda je token metadat k dispozici pro zadaného člena.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaný člen a volitelně se použijí na jeho nadřazené objekty.
IsDefined(MemberInfo, Type)	Určuje, zda jsou u zadaného člena použity vlastní atributy zadaného typu.

Viz také

• Postupy: Definování a spouštění dynamických metod
• Problémy se zabezpečením v Emitování Reflexe
• Návod: Generování kódu ve scénářích částečné důvěryhodnosti