DynamicMethod Klasa

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Emit.Lightweight.dll

Zestaw:

mscorlib.dll

Zestaw:

netstandard.dll

Definiuje i reprezentuje metodę dynamiczną, którą można skompilować, wykonać i odrzucić. Odrzucone metody są dostępne dla odzyskiwania pamięci.

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

public sealed class DynamicMethod : System.Reflection.MethodInfo

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo

type DynamicMethod = class
    inherit MethodInfo

[<System.Runtime.InteropServices.ComVisible(true)>]
type DynamicMethod = class
    inherit MethodInfo

Public NotInheritable Class DynamicMethod
Inherits MethodInfo

Dziedziczenie

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Atrybuty

ComVisibleAttribute

Przykłady

Poniższy przykład kodu tworzy metodę dynamiczną, która przyjmuje dwa parametry. Przykład emituje prostą treść funkcji, która wyświetla pierwszy parametr w konsoli, a w przykładzie użyto drugiego parametru jako wartości zwracanej metody. Przykład kończy metodę, tworząc delegata, wywołuje delegata z różnymi parametrami, a na koniec wywołuje metodę dynamiczną Invoke przy użyciu metody .

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Globalization;

// Declare a delegate type that can be used to execute the completed
// dynamic method. 
private delegate int HelloDelegate(String^ msg, int ret);

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.
    array<Type^>^ helloArgs = { String::typeid, int::typeid };

    // 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 = gcnew DynamicMethod("Hello", 
        int::typeid, 
        helloArgs, 
        String::typeid->Module);

    // Create an array that specifies the parameter types of the
    // overload of Console::WriteLine to be used in Hello.
    array<Type^>^ writeStringArgs = { String::typeid };
    // Get the overload of Console::WriteLine that has one
    // String parameter.
    MethodInfo^ writeString = Console::typeid->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, nullptr);
    // 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(HelloDelegate::typeid);

    // 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.
    array<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(nullptr, BindingFlags::ExactBinding, nullptr, invokeArgs, gcnew 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 == nullptr)
    {
        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 == nullptr)
    {
        Console::WriteLine("\r\nReflectedType is null.");
    }
    else
    {
        Console::WriteLine("\r\nReflectedType: {0}", hello->ReflectedType);
    }

    if (hello->ReturnParameter == nullptr)
    {
        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 == Void::typeid)
    {
        Console::WriteLine("The method has no return type.");
    }
    else
    {
        ICustomAttributeProvider^ caProvider = hello->ReturnTypeCustomAttributes;
        array<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:");
            for each (Object^ attr in returnAttributes)
            {
                Console::WriteLine("\t{0}", attr->ToString());
            }
        }
    }

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

    // Display parameter information.
    array<ParameterInfo^>^ parameters = hello->GetParameters();
    Console::WriteLine("\r\nParameters: name, type, ParameterAttributes");
    for each (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
 */

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

Uwagi

Za pomocą DynamicMethod klasy można wygenerować i wykonać metodę w czasie wykonywania bez konieczności generowania zestawu dynamicznego i typu dynamicznego, aby zawierać metodę . Kod wykonywalny utworzony przez kompilator just in time (JIT) jest odzyskiwane po odzyskaniu DynamicMethod obiektu. Metody dynamiczne to najbardziej wydajny sposób generowania i wykonywania małych ilości kodu.

Metoda dynamiczna może być hostowana anonimowo lub może być logicznie skojarzona z modułem lub typem.

• Jeśli metoda dynamiczna jest hostowana anonimowo, znajduje się w zestawie dostarczonym przez system i dlatego jest odizolowana od innego kodu. Domyślnie nie ma dostępu do żadnych danych innych niż publiczne. Anonimowo hostowana metoda dynamiczna może mieć ograniczoną możliwość pomijania kontroli widoczności kompilatora JIT, jeśli została ona udzielona ReflectionPermission z flagą ReflectionPermissionFlag.RestrictedMemberAccess . Poziom zaufania zestawu, do którego niepubliczna elementy członkowskie są dostępne przez metodę dynamiczną, musi być równy lub podzestawowi poziomu zaufania stosu wywołań, który emitował metodę dynamiczną. Aby uzyskać więcej informacji na temat anonimowo hostowanych metod dynamicznych, zobacz Przewodnik: emitowanie kodu w scenariuszach częściowego zaufania.

• Jeśli metoda dynamiczna jest skojarzona z określonym modułem, metoda dynamiczna jest efektywnie globalna dla tego modułu. Może uzyskać dostęp do wszystkich typów w module i wszystkich internal (Friend w Visual Basic) składowych typów. Metodę dynamiczną można skojarzyć z dowolnym modułem, niezależnie od tego, czy moduł został utworzony, pod warunkiem, że żądanie ReflectionPermission dla flagi RestrictedMemberAccess może być spełnione przez stos wywołań, który zawiera kod. Jeśli flaga ReflectionPermissionFlag.MemberAccess jest uwzględniona w przyznaniu, metoda dynamiczna może pominąć kontrole widoczności kompilatora JIT i uzyskać dostęp do prywatnych danych wszystkich typów zadeklarowanych w module lub w dowolnym innym module w dowolnym zestawie.

  Uwaga

  Po określeniu modułu, z którym jest skojarzona metoda dynamiczna, ten moduł nie może znajdować się w zestawie dostarczonym przez system, który jest używany do hostingu anonimowego.

• Jeśli metoda dynamiczna jest skojarzona z określonym typem, ma dostęp do wszystkich elementów członkowskich typu, niezależnie od poziomu dostępu. Ponadto można pominąć kontrole widoczności JIT. Zapewnia to dynamiczny dostęp metody do prywatnych danych innych typów zadeklarowanych w tym samym module lub w dowolnym innym module w dowolnym zestawie. Metodę dynamiczną można skojarzyć z dowolnym typem, ale kod musi zostać przyznany ReflectionPermission zarówno z flagami , jak RestrictedMemberAccess i MemberAccess .

W poniższej tabeli pokazano, które typy i elementy członkowskie są dostępne dla metody dynamicznej hostowanej anonimowo, z sprawdzaniem widoczności JIT i bez niego, w zależności od tego, czy ReflectionPermission flaga RestrictedMemberAccess jest udzielana.

	Bez RestrictedMemberAccess	Z RestrictedMemberAccess
Bez pomijania kontroli widoczności JIT	Publiczne elementy członkowskie typów publicznych w dowolnym zestawie.	Publiczne elementy członkowskie typów publicznych w dowolnym zestawie.
Pomijanie kontroli widoczności JIT z ograniczeniami	Publiczne elementy członkowskie typów publicznych w dowolnym zestawie.	Wszystkie elementy członkowskie wszystkich typów, tylko w zestawach, których poziomy zaufania są równe lub mniejsze niż poziom zaufania zestawu, który emitował metodę dynamiczną.

Uwaga

.NET Framework 2.0 umożliwia emitowanie kodu w scenariuszach częściowego zaufania bez wystawiania żadnych wymagań dotyczących zabezpieczeń, ponieważ generowanie kodu nie jest z natury operacją uprzywilejowaną. Oznacza to, że wygenerowany kod nie ma więcej uprawnień niż zestaw, który go emituje. Dzięki temu biblioteki emitujące kod są niewidoczne dla zabezpieczeń i eliminuje konieczność potwierdzenia ReflectionEmit, co upraszcza zadanie pisania bezpiecznej biblioteki. Aby użyć tej funkcji, aplikacja powinna być przeznaczona dla .NET Framework 3.5 lub nowszej.

W poniższej tabeli przedstawiono typy i składowe dostępne dla metody dynamicznej skojarzonej z modułem lub typu w module.

	Skojarzone z modułem	Skojarzone z typem
Bez pomijania kontroli widoczności JIT	Publiczne i wewnętrzne elementy członkowskie typów publicznych, wewnętrznych i prywatnych w module. Publiczne elementy członkowskie typów publicznych w dowolnym zestawie.	Wszyscy członkowie skojarzonego typu. Publiczne i wewnętrzne elementy członkowskie wszystkich innych typów w module. Publiczne elementy członkowskie typów publicznych w dowolnym zestawie.
Pomijanie kontroli widoczności trybu JIT	Wszystkie elementy członkowskie wszystkich typów w dowolnym zestawie.	Wszystkie elementy członkowskie wszystkich typów w dowolnym zestawie.

Metoda dynamiczna skojarzona z modułem ma uprawnienia tego modułu. Metoda dynamiczna skojarzona z typem ma uprawnienia modułu zawierającego ten typ.

Metody dynamiczne i ich parametry nie muszą być nazwane, ale można określić nazwy, aby ułatwić debugowanie. Atrybuty niestandardowe nie są obsługiwane w przypadku metod dynamicznych ani ich parametrów.

Mimo że metody dynamiczne są static metodami (Sharedmetodami w Visual Basic), swobodne reguły powiązania delegata wprowadzone w .NET Framework 2.0 umożliwiają powiązanie metody dynamicznej z obiektem, tak aby działało jak metoda wystąpienia, gdy jest wywoływana przy użyciu tego wystąpienia delegata. Przykład, który demonstruje to, jest dostarczany dla przeciążenia CreateDelegate(Type, Object) metody.

Uwaga

W .NET Framework 2.0 metody dynamiczne nie obsługują informacji o symbolach, czyli lokalnych nazw zmiennych i mapowania numerów wierszy. To ograniczenie może zostać usunięte w przyszłej wersji. Podczas programowania można AssemblyBuilder uprościć debugowanie wygenerowanego języka Microsoft Intermediate Language (MSIL), a następnie przełączyć się na metody dynamiczne podczas końcowego wdrażania, ponieważ ILGenerator wywołania są takie same w obu przypadkach.

Weryfikacja

Poniższa lista zawiera podsumowanie warunków, w których metody dynamiczne mogą zawierać nieweryfikowalny kod. (Na przykład metoda dynamiczna jest niemożliwa do zweryfikowania, jeśli jej InitLocals właściwość jest ustawiona na falsewartość .)

• Metoda dynamiczna skojarzona z zestawem krytycznym pod względem zabezpieczeń jest również krytyczna dla zabezpieczeń i może pominąć weryfikację. Na przykład zestaw bez atrybutów zabezpieczeń, który jest uruchamiany jako aplikacja klasyczna, jest traktowany jako krytyczny pod względem zabezpieczeń przez środowisko uruchomieniowe. Jeśli skojarzysz metodę dynamiczną z zestawem, metoda dynamiczna może zawierać nieweryfikowalny kod.

• Jeśli metoda dynamiczna zawierająca nieweryfikowalny kod jest skojarzona z zestawem o przezroczystości na poziomie 1, kompilator just in time (JIT) wprowadza zapotrzebowanie na zabezpieczenia. Zapotrzebowanie powiedzie się tylko wtedy, gdy metoda dynamiczna jest wykonywana przez w pełni zaufany kod. Zobacz Kod przezroczysty dla zabezpieczeń, poziom 1.

• Jeśli metoda dynamiczna zawierająca nieweryfikowalny kod jest skojarzona z zestawem, który ma przezroczystość poziomu 2 (na przykład mscorlib.dll), zgłasza wyjątek (wstrzykiwany przez kompilator JIT) zamiast żądać zabezpieczeń. Zobacz Kod przezroczysty dla zabezpieczeń, poziom 2.

• Anonimowo hostowana metoda dynamiczna zawierająca nieweryfikowalny kod zawsze zgłasza wyjątek. Nigdy nie może pominąć weryfikacji, nawet jeśli jest tworzona i wykonywana przez w pełni zaufany kod.

Wyjątek zgłaszany dla nieweryfikowalnego kodu różni się w zależności od sposobu wywoływanego metody dynamicznej. Jeśli wywołasz metodę dynamiczną przy użyciu delegata zwróconego z CreateDelegate metody , VerificationException element zostanie zgłoszony. Jeśli wywołasz metodę dynamiczną przy użyciu Invoke metody , TargetInvocationException element jest zgłaszany z wewnętrznym VerificationExceptionelementem .

Konstruktory

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Tworzy metodę dynamiczną, która jest globalna dla modułu, określając nazwę metody, atrybuty, konwencję wywoływania, typ zwracany, typy parametrów, moduł i czy kontrole widoczności just in time (JIT) powinny zostać pominięte dla typów i elementów członkowskich, do których uzyskuje dostęp język pośredni firmy Microsoft (MSIL) metody dynamicznej.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Tworzy metodę dynamiczną, określając nazwę metody, atrybuty, konwencję wywoływania, typ zwracany, typy parametrów, typ, z którym metoda dynamiczna jest logicznie skojarzona, oraz czy kontrole widoczności just in time (JIT) powinny zostać pominięte dla typów i elementów członkowskich, do których uzyskuje się dostęp przez język pośrednich firmy Microsoft (MSIL) metody dynamicznej.
DynamicMethod(String, Type, Type[])	Inicjuje anonimowo hostowaną metodę dynamiczną, określając nazwę metody, typ zwracany i typy parametrów.
DynamicMethod(String, Type, Type[], Boolean)	Inicjuje anonimowo hostowaną metodę dynamiczną, określając nazwę metody, typ zwracany, typy parametrów i czy sprawdzanie widoczności just in time (JIT) powinno zostać pominięte dla typów i elementów członkowskich, do których uzyskuje dostęp język pośredni Microsoft (MSIL) metody dynamicznej.
DynamicMethod(String, Type, Type[], Module)	Tworzy metodę dynamiczną, która jest globalna dla modułu, określając nazwę metody, typ zwracany, typy parametrów i moduł.
DynamicMethod(String, Type, Type[], Module, Boolean)	Tworzy metodę dynamiczną, która jest globalna dla modułu, określając nazwę metody, typ zwracany, typy parametrów, moduł oraz to, czy kontrole widoczności just in time (JIT) powinny być pomijane dla typów i elementów członkowskich dostępnych przez język microsoft intermediate language (MSIL) metody dynamicznej.
DynamicMethod(String, Type, Type[], Type)	Tworzy metodę dynamiczną, określając nazwę metody, typ zwracany, typy parametrów i typ, z którym metoda dynamiczna jest logicznie skojarzona.
DynamicMethod(String, Type, Type[], Type, Boolean)	Tworzy metodę dynamiczną, określając nazwę metody, typ zwracany, typy parametrów, typ, z którym metoda dynamiczna jest logicznie skojarzona i czy kontrole widoczności just in time (JIT) powinny zostać pominięte dla typów i elementów członkowskich, do których uzyskuje się dostęp przez język pośredni firmy Microsoft (MSIL) metody dynamicznej.

Właściwości

Attributes	Pobiera atrybuty określone podczas tworzenia metody dynamicznej.
CallingConvention	Pobiera konwencję wywoływania określoną podczas tworzenia metody dynamicznej.
ContainsGenericParameters	Pobiera wartość wskazującą, czy metoda ogólna zawiera nieprzypisane parametry typu ogólnego. (Odziedziczone po MethodInfo)
CustomAttributes	Pobiera kolekcję zawierającą atrybuty niestandardowe tego elementu członkowskiego. (Odziedziczone po MemberInfo)
DeclaringType	Pobiera typ, który deklaruje metodę , która jest zawsze null dla metod dynamicznych.
InitLocals	Pobiera lub ustawia wartość wskazującą, czy zmienne lokalne w metodzie są inicjowane zero.
IsAbstract	Pobiera wartość wskazującą, czy metoda jest abstrakcyjna. (Odziedziczone po MethodBase)
IsAssembly	Pobiera wartość wskazującą, czy potencjalna widoczność tej metody lub konstruktora jest opisana przez Assemblymetodę , czyli metodę lub konstruktora jest widoczna co najwyżej dla innych typów w tym samym zestawie i nie jest widoczna dla typów pochodnych poza zestawem. (Odziedziczone po MethodBase)
IsCollectible	Pobiera wartość wskazującą, czy ten MemberInfo obiekt jest częścią zestawu przechowywanego w obiekcie zbieralnym AssemblyLoadContext. (Odziedziczone po MemberInfo)
IsConstructedGenericMethod	(Odziedziczone po MethodBase)
IsConstructor	Pobiera wartość wskazującą, czy metoda jest konstruktorem. (Odziedziczone po MethodBase)
IsFamily	Pobiera wartość wskazującą, czy widoczność tej metody lub konstruktora jest opisana przez Familymetodę , czyli metodę lub konstruktor jest widoczna tylko w jej klasach i klasach pochodnych. (Odziedziczone po MethodBase)
IsFamilyAndAssembly	Pobiera wartość wskazującą, czy widoczność tej metody lub konstruktora jest opisana przez FamANDAssemmetodę , czyli metodę lub konstruktor może być wywoływana przez klasy pochodne, ale tylko wtedy, gdy znajdują się w tym samym zestawie. (Odziedziczone po MethodBase)
IsFamilyOrAssembly	Pobiera wartość wskazującą, czy potencjalna widoczność tej metody lub konstruktora jest opisana przez FamORAssemmetodę , czyli metodę lub konstruktora może być wywoływana przez klasy pochodne wszędzie tam, gdzie są, oraz według klas w tym samym zestawie. (Odziedziczone po MethodBase)
IsFinal	Pobiera wartość wskazującą, czy ta metoda to final. (Odziedziczone po MethodBase)
IsGenericMethod	Pobiera wartość wskazującą, czy bieżąca metoda jest metodą ogólną. (Odziedziczone po MethodInfo)
IsGenericMethodDefinition	Pobiera wartość wskazującą, czy bieżący MethodInfo reprezentuje definicję metody ogólnej. (Odziedziczone po MethodInfo)
IsHideBySig	Pobiera wartość wskazującą, czy tylko element członkowski tego samego rodzaju z dokładnie tym samym podpisem jest ukryty w klasie pochodnej. (Odziedziczone po MethodBase)
IsPrivate	Pobiera wartość wskazującą, czy ten element członkowski jest prywatny. (Odziedziczone po MethodBase)
IsPublic	Pobiera wartość wskazującą, czy jest to metoda publiczna. (Odziedziczone po MethodBase)
IsSecurityCritical	Pobiera wartość wskazującą, czy bieżąca metoda dynamiczna jest krytyczna pod względem zabezpieczeń, czy bezpieczna pod względem zabezpieczeń, i w związku z tym może wykonywać operacje krytyczne.
IsSecurityCritical	Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor ma krytyczne znaczenie dla zabezpieczeń, czy bezpieczne zabezpieczenia na bieżącym poziomie zaufania, a w związku z tym może wykonywać operacje krytyczne. (Odziedziczone po MethodBase)
IsSecuritySafeCritical	Pobiera wartość wskazującą, czy bieżąca metoda dynamiczna ma krytyczne znaczenie dla bezpieczeństwa na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskiwać do niego dostęp za pomocą przezroczystego kodu.
IsSecuritySafeCritical	Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor ma krytyczne znaczenie dla bezpieczeństwa na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskać do niego dostęp za pomocą przezroczystego kodu. (Odziedziczone po MethodBase)
IsSecurityTransparent	Pobiera wartość wskazującą, czy bieżąca metoda dynamiczna jest przezroczysta na bieżącym poziomie zaufania i dlatego nie może wykonywać operacji krytycznych.
IsSecurityTransparent	Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor jest przezroczysta na bieżącym poziomie zaufania, a zatem nie może wykonywać operacji krytycznych. (Odziedziczone po MethodBase)
IsSpecialName	Pobiera wartość wskazującą, czy ta metoda ma specjalną nazwę. (Odziedziczone po MethodBase)
IsStatic	Pobiera wartość wskazującą, czy metoda to static. (Odziedziczone po MethodBase)
IsVirtual	Pobiera wartość wskazującą, czy metoda to virtual. (Odziedziczone po MethodBase)
MemberType	Pobiera wartość wskazującą MemberTypes , że ten element członkowski jest metodą. (Odziedziczone po MethodInfo)
MetadataToken	Pobiera wartość identyfikującą element metadanych. (Odziedziczone po MemberInfo)
MethodHandle	Nieobsługiwane w przypadku metod dynamicznych.
MethodHandle	Pobiera uchwyt do wewnętrznej reprezentacji metadanych metody. (Odziedziczone po MethodBase)
MethodImplementationFlags
MethodImplementationFlags	MethodImplAttributes Pobiera flagi określające atrybuty implementacji metody. (Odziedziczone po MethodBase)
Module	Pobiera moduł, za pomocą którego metoda dynamiczna jest logicznie skojarzona.
Module	Pobiera moduł, w którym typ, który deklaruje element członkowski reprezentowany przez bieżący MemberInfo jest zdefiniowany. (Odziedziczone po MemberInfo)
Name	Pobiera nazwę metody dynamicznej.
ReflectedType	Pobiera klasę, która została użyta w odbiciu w celu uzyskania metody.
ReflectedType	Pobiera obiekt klasy, który został użyty do uzyskania tego wystąpienia klasy MemberInfo. (Odziedziczone po MemberInfo)
ReturnParameter	Pobiera parametr zwrotny metody dynamicznej.
ReturnType	Pobiera typ zwracanej wartości dla metody dynamicznej.
ReturnTypeCustomAttributes	Pobiera atrybuty niestandardowe typu zwracanego dla metody dynamicznej.
ReturnTypeCustomAttributes	Pobiera atrybuty niestandardowe dla typu zwracanego. (Odziedziczone po MethodInfo)

Metody

CreateDelegate(Type)	Kończy metodę dynamiczną i tworzy delegata, którego można użyć do jego wykonania.
CreateDelegate(Type, Object)	Kończy metodę dynamiczną i tworzy delegata, którego można użyć do jego wykonania, określając typ delegata i obiekt, do którego jest powiązany delegat.
CreateDelegate<T>()	Tworzy delegata typu T na podstawie tej metody. (Odziedziczone po MethodInfo)
CreateDelegate<T>(Object)	Tworzy delegata typu T z określonym obiektem docelowym z tej metody. (Odziedziczone po MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	Definiuje parametr metody dynamicznej.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi. (Odziedziczone po MethodInfo)
GetBaseDefinition()	Zwraca podstawową implementację metody .
GetBaseDefinition()	Po zastąpieniu w klasie pochodnej zwraca MethodInfo obiekt dla metody w bezpośrednich lub pośrednich klasach bazowych, w której metoda reprezentowana przez to wystąpienie została po raz pierwszy zadeklarowana. (Odziedziczone po MethodInfo)
GetCustomAttributes(Boolean)	Zwraca wszystkie atrybuty niestandardowe zdefiniowane dla metody .
GetCustomAttributes(Boolean)	Po zastąpieniu w klasie pochodnej zwraca tablicę wszystkich atrybutów niestandardowych zastosowanych do tego elementu członkowskiego. (Odziedziczone po MemberInfo)
GetCustomAttributes(Type, Boolean)	Zwraca atrybuty niestandardowe określonego typu, które zostały zastosowane do metody .
GetCustomAttributes(Type, Boolean)	Po przesłonięciu w klasie pochodnej zwraca tablicę atrybutów niestandardowych zastosowanych do tego elementu członkowskiego i zidentyfikowaną przez Typeelement . (Odziedziczone po MemberInfo)
GetCustomAttributesData()	Zwraca listę CustomAttributeData obiektów reprezentujących dane dotyczące atrybutów, które zostały zastosowane do elementu docelowego. (Odziedziczone po MemberInfo)
GetDynamicILInfo()	DynamicILInfo Zwraca obiekt, który może służyć do generowania treści metody na podstawie tokenów metadanych, zakresów i strumieni języka microsoft intermediate language (MSIL).
GetGenericArguments()	Zwraca tablicę Type obiektów reprezentujących argumenty typu metody ogólnej lub parametry typu definicji metody ogólnej. (Odziedziczone po MethodInfo)
GetGenericMethodDefinition()	Zwraca obiekt reprezentujący definicję MethodInfo metody ogólnej, z której można utworzyć bieżącą metodę. (Odziedziczone po MethodInfo)
GetHashCode()	Zwraca wartość skrótu dla tego wystąpienia. (Odziedziczone po MethodInfo)
GetILGenerator()	Zwraca generator języka microsoft intermediate language (MSIL) dla metody z domyślnym rozmiarem strumienia MSIL o rozmiarze 64 bajtów.
GetILGenerator(Int32)	Zwraca generator języka Microsoft Intermediate Language (MSIL) dla metody o określonym rozmiarze strumienia MSIL.
GetMethodBody()	Po zastąpieniu w klasie pochodnej pobiera MethodBody obiekt, który zapewnia dostęp do strumienia MSIL, zmiennych lokalnych i wyjątków dla bieżącej metody. (Odziedziczone po MethodBase)
GetMethodImplementationFlags()	Zwraca flagi implementacji dla metody .
GetMethodImplementationFlags()	Po przesłonięciu MethodImplAttributes w klasie pochodnej zwraca flagi. (Odziedziczone po MethodBase)
GetParameters()	Zwraca parametry metody dynamicznej.
GetType()	Odnajduje atrybuty metody i zapewnia dostęp do metadanych metody. (Odziedziczone po MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	(Odziedziczone po MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Wywołuje metodę dynamiczną przy użyciu określonych parametrów w ramach ograniczeń określonego powiązania z określonymi informacjami o kulturze.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Podczas zastępowania w klasie pochodnej wywołuje odbitą metodę lub konstruktor z podanymi parametrami. (Odziedziczone po MethodBase)
Invoke(Object, Object[])	Wywołuje metodę lub konstruktor reprezentowany przez bieżące wystąpienie przy użyciu określonych parametrów. (Odziedziczone po MethodInfo)
IsDefined(Type, Boolean)	Wskazuje, czy określony typ atrybutu niestandardowego jest zdefiniowany.
IsDefined(Type, Boolean)	Po przesłonięciu w klasie pochodnej wskazuje, czy do tego elementu członkowskiego zastosowano co najmniej jeden atrybut określonego typu lub jego typów pochodnych. (Odziedziczone po MemberInfo)
MakeGenericMethod(Type[])	Zastępuje elementy tablicy typów dla parametrów typu bieżącej definicji metody ogólnej i zwraca obiekt reprezentujący wynikową skonstruowaną metodę MethodInfo . (Odziedziczone po MethodInfo)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca podpis metody reprezentowanej jako ciąg.

Jawne implementacje interfejsu

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. (Odziedziczone po MemberInfo)
_MemberInfo.GetType()	Type Pobiera obiekt reprezentujący klasęMemberInfo. (Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu. (Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). (Odziedziczone po MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. (Odziedziczone po MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. (Odziedziczone po MethodBase)
_MethodBase.GetType()	Aby uzyskać opis tego elementu członkowskiego, zobacz GetType(). (Odziedziczone po MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu. (Odziedziczone po MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). (Odziedziczone po MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. (Odziedziczone po MethodBase)
_MethodBase.IsAbstract	Aby uzyskać opis tego elementu członkowskiego, zobacz IsAbstract. (Odziedziczone po MethodBase)
_MethodBase.IsAssembly	Aby uzyskać opis tego elementu członkowskiego, zobacz IsAssembly. (Odziedziczone po MethodBase)
_MethodBase.IsConstructor	Aby uzyskać opis tego elementu członkowskiego, zobacz IsConstructor. (Odziedziczone po MethodBase)
_MethodBase.IsFamily	Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamily. (Odziedziczone po MethodBase)
_MethodBase.IsFamilyAndAssembly	Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamilyAndAssembly. (Odziedziczone po MethodBase)
_MethodBase.IsFamilyOrAssembly	Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamilyOrAssembly. (Odziedziczone po MethodBase)
_MethodBase.IsFinal	Aby uzyskać opis tego elementu członkowskiego, zobacz IsFinal. (Odziedziczone po MethodBase)
_MethodBase.IsHideBySig	Aby uzyskać opis tego elementu członkowskiego, zobacz IsHideBySig. (Odziedziczone po MethodBase)
_MethodBase.IsPrivate	Aby uzyskać opis tego elementu członkowskiego, zobacz IsPrivate. (Odziedziczone po MethodBase)
_MethodBase.IsPublic	Aby uzyskać opis tego elementu członkowskiego, zobacz IsPublic. (Odziedziczone po MethodBase)
_MethodBase.IsSpecialName	Aby uzyskać opis tego elementu członkowskiego, zobacz IsSpecialName. (Odziedziczone po MethodBase)
_MethodBase.IsStatic	Aby uzyskać opis tego elementu członkowskiego, zobacz IsStatic. (Odziedziczone po MethodBase)
_MethodBase.IsVirtual	Aby uzyskać opis tego członka, zobacz IsVirtual. (Odziedziczone po MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. (Odziedziczone po MethodInfo)
_MethodInfo.GetType()	Zapewnia dostęp do GetType() metody z modelu COM. (Odziedziczone po MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Pobiera informacje o typie dla obiektu, który może służyć do pobierania informacji o typie dla interfejsu. (Odziedziczone po MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)	Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). (Odziedziczone po MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. (Odziedziczone po MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Zwraca tablicę wszystkich atrybutów niestandardowych zdefiniowanych w tym elemencie członkowskim, z wyłączeniem nazwanych atrybutów lub pustą tablicą, jeśli nie ma atrybutów niestandardowych. (Odziedziczone po MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Zwraca tablicę atrybutów niestandardowych zdefiniowanych na tym elemencie członkowskim, identyfikowaną przez typ lub pustą tablicę, jeśli nie ma atrybutów niestandardowych tego typu. (Odziedziczone po MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Wskazuje, czy na tym elemencie członkowskim zdefiniowano jedno lub więcej wystąpień attributeType . (Odziedziczone po MemberInfo)

Metody rozszerzania

GetCustomAttribute(MemberInfo, Type)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.
GetCustomAttribute(MemberInfo, Type, Boolean)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza elementów podrzędnych tego elementu członkowskiego.
GetCustomAttribute<T>(MemberInfo)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.
GetCustomAttribute<T>(MemberInfo, Boolean)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza elementów podrzędnych tego elementu członkowskiego.
GetCustomAttributes(MemberInfo)	Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Boolean)	Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza elementy charakterystyczne tego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Type)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Type, Boolean)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza elementów podrzędnych tego elementu członkowskiego.
GetCustomAttributes<T>(MemberInfo)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes<T>(MemberInfo, Boolean)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza elementów podrzędnych tego elementu członkowskiego.
IsDefined(MemberInfo, Type)	Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego.
IsDefined(MemberInfo, Type, Boolean)	Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego, a opcjonalnie stosowane do jego elementów nadrzędnych.
GetMetadataToken(MemberInfo)	Pobiera token metadanych dla danego elementu członkowskiego, jeśli jest dostępny.
HasMetadataToken(MemberInfo)	Zwraca wartość wskazującą, czy token metadanych jest dostępny dla określonego elementu członkowskiego.
GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)	Pobiera obiekt reprezentujący określoną metodę w bezpośrednich lub pośrednich klasach bazowych, w których metoda została po raz pierwszy zadeklarowana.

Zobacz też

• Instrukcje: Definiowanie i wykonywanie metod dynamicznych
• Problemy związane z zabezpieczeniami w emisji odbicia
• Przewodnik: Emitowanie kodu w scenariuszach częściowo zaufanych