DynamicMethod Klass

Definition

Namnområde:

System.Reflection.Emit

Sammansättning:

mscorlib.dll

Definierar och representerar en dynamisk metod som kan kompileras, köras och ignoreras. Borttagna metoder är tillgängliga för skräpinsamling.

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

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

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

Public NotInheritable Class DynamicMethod
Inherits MethodInfo

Arv

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Attribut

ComVisibleAttribute

Exempel

I följande kodexempel skapas en dynamisk metod som tar två parametrar. Exemplet genererar en enkel funktionstext som skriver ut den första parametern till konsolen, och i exemplet används den andra parametern som returvärde för metoden. Exemplet slutför metoden genom att skapa ett ombud, anropar ombudet med olika parametrar och anropar slutligen den dynamiska metoden med hjälp av Invoke metoden.

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

Kommentarer

Mer information om det här API:et finns i Kompletterande API-kommentarer för DynamicMethod.

Konstruktorer

Name	Description
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Skapar en dynamisk metod som är global för en modul och anger metodnamn, attribut, anropande konvention, returtyp, parametertyper, modul och om jit-synlighetskontroller (just-in-time) ska hoppas över för typer och medlemmar som används av den dynamiska metodens Microsoft mellanliggande språk (MSIL).
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Skapar en dynamisk metod som anger metodens namn, attribut, anropar konvention, returtyp, parametertyper, den typ som den dynamiska metoden är logiskt associerad med och om jit-synlighetskontroller (just-in-time) ska hoppas över för typer och medlemmar som används av den dynamiska metodens Microsoft mellanliggande språk (MSIL).
DynamicMethod(String, Type, Type[], Boolean)	Initierar en anonymt värdbaserad dynamisk metod som anger metodnamn, returtyp, parametertyper och om jit-synlighetskontroller (just-in-time) ska hoppas över för typer och medlemmar som används av Microsoft mellanliggande språk (MSIL) för den dynamiska metoden.
DynamicMethod(String, Type, Type[], Module, Boolean)	Skapar en dynamisk metod som är global för en modul, som anger metodnamn, returtyp, parametertyper, modul och om jit-synlighetskontroller (just-in-time) ska hoppas över för typer och medlemmar som används av Microsoft mellanliggande språk (MSIL) för den dynamiska metoden.
DynamicMethod(String, Type, Type[], Module)	Skapar en dynamisk metod som är global för en modul och anger metodnamnet, returtypen, parametertyperna och modulen.
DynamicMethod(String, Type, Type[], Type, Boolean)	Skapar en dynamisk metod som anger metodnamnet, returtypen, parametertyperna, typen som den dynamiska metoden är logiskt associerad med och om jit-synlighetskontroller (just-in-time) ska hoppas över för typer och medlemmar som används av den dynamiska metodens Microsoft mellanliggande språk (MSIL).
DynamicMethod(String, Type, Type[], Type)	Skapar en dynamisk metod som anger metodnamnet, returtypen, parametertyperna och den typ som den dynamiska metoden är logiskt associerad med.
DynamicMethod(String, Type, Type[])	Initierar en anonymt värdbaserad dynamisk metod som anger metodnamn, returtyp och parametertyper.

Egenskaper

Name	Description
Attributes	Hämtar de attribut som angavs när den dynamiska metoden skapades.
CallingConvention	Hämtar den anropskonvention som angavs när den dynamiska metoden skapades.
CustomAttributes	Hämtar en samling som innehåller den här medlemmens anpassade attribut. (Ärvd från MemberInfo)
DeclaringType	Hämtar den typ som deklarerar metoden, som alltid null används för dynamiska metoder.
InitLocals	Hämtar eller anger ett värde som anger om de lokala variablerna i metoden är nollinitierade.
IsAbstract	Hämtar ett värde som anger om metoden är abstrakt. (Ärvd från MethodBase)
IsAssembly	Hämtar ett värde som anger om den potentiella synligheten för den här metoden eller konstruktorn beskrivs av Assembly. Metoden eller konstruktorn visas som mest för andra typer i samma sammansättning och är inte synlig för härledda typer utanför sammansättningen. (Ärvd från MethodBase)
IsConstructor	Hämtar ett värde som anger om metoden är en konstruktor. (Ärvd från MethodBase)
IsFamily	Hämtar ett värde som anger om synligheten för den här metoden eller konstruktorn beskrivs av Family, det vill sägs att metoden eller konstruktorn endast visas inom dess klass och härledda klasser. (Ärvd från MethodBase)
IsFamilyAndAssembly	Hämtar ett värde som anger om synligheten för den här metoden eller konstruktorn beskrivs av FamANDAssem. Metoden eller konstruktorn kan anropas av härledda klasser, men bara om de finns i samma sammansättning. (Ärvd från MethodBase)
IsFamilyOrAssembly	Hämtar ett värde som anger om den potentiella synligheten för den här metoden eller konstruktorn beskrivs av FamORAssem. Det innebär att metoden eller konstruktorn kan anropas av härledda klasser var de än befinner sig och efter klasser i samma sammansättning. (Ärvd från MethodBase)
IsFinal	Hämtar ett värde som anger om den här metoden är final. (Ärvd från MethodBase)
IsHideBySig	Hämtar ett värde som anger om endast en medlem av samma typ med exakt samma signatur är dold i den härledda klassen. (Ärvd från MethodBase)
IsPrivate	Hämtar ett värde som anger om den här medlemmen är privat. (Ärvd från MethodBase)
IsPublic	Hämtar ett värde som anger om det här är en offentlig metod. (Ärvd från MethodBase)
IsSecurityCritical	Hämtar ett värde som anger om den aktuella dynamiska metoden är säkerhetskritisk eller säkerhetssäker och därför kan utföra kritiska åtgärder.
IsSecuritySafeCritical	Hämtar ett värde som anger om den aktuella dynamiska metoden är säkerhetssäker-kritisk på den aktuella förtroendenivån. det vill: om den kan utföra kritiska åtgärder och kan nås med transparent kod.
IsSecurityTransparent	Hämtar ett värde som anger om den aktuella dynamiska metoden är transparent på den aktuella förtroendenivån och därför inte kan utföra kritiska åtgärder.
IsSpecialName	Hämtar ett värde som anger om den här metoden har ett särskilt namn. (Ärvd från MethodBase)
IsStatic	Hämtar ett värde som anger om metoden är static. (Ärvd från MethodBase)
IsVirtual	Hämtar ett värde som anger om metoden är virtual. (Ärvd från MethodBase)
MemberType	Hämtar ett MemberTypes värde som anger att den här medlemmen är en metod. (Ärvd från MethodInfo)
MetadataToken	Hämtar ett värde som identifierar ett metadataelement. (Ärvd från MemberInfo)
MethodHandle	Stöds inte för dynamiska metoder.
MethodImplementationFlags	MethodImplAttributes Hämtar flaggorna som anger attributen för en metodimplementering. (Ärvd från MethodBase)
Module	Hämtar modulen som den dynamiska metoden är logiskt associerad med.
Name	Hämtar namnet på den dynamiska metoden.
ReflectedType	Hämtar klassen som användes i reflektion för att hämta metoden.
ReturnParameter	Hämtar returparametern för den dynamiska metoden.
ReturnType	Hämtar typen av returvärde för den dynamiska metoden.
ReturnTypeCustomAttributes	Hämtar anpassade attribut för returtypen för den dynamiska metoden.

Metoder

Name	Description
CreateDelegate(Type, Object)	Slutför den dynamiska metoden och skapar ett ombud som kan användas för att köra den och anger ombudstypen och ett objekt som ombudet är bundet till.
CreateDelegate(Type)	Slutför den dynamiska metoden och skapar ett ombud som kan användas för att köra den.
DefineParameter(Int32, ParameterAttributes, String)	Definierar en parameter för den dynamiska metoden.
Equals(Object)	Returnerar ett värde som anger om den här instansen är lika med ett angivet objekt. (Ärvd från MethodInfo)
GetBaseDefinition()	Returnerar basimplementeringen för metoden.
GetCustomAttributes(Boolean)	Returnerar alla anpassade attribut som definierats för metoden.
GetCustomAttributes(Type, Boolean)	Returnerar de anpassade attributen för den angivna typen som har tillämpats på metoden.
GetCustomAttributesData()	Returnerar en lista över CustomAttributeData objekt som representerar data om de attribut som har tillämpats på målmedlemmen. (Ärvd från MemberInfo)
GetDynamicILInfo()	Returnerar ett DynamicILInfo objekt som kan användas för att generera en metodtext från metadatatoken, omfång och Microsoft MSIL-strömmar (intermediate language).
GetGenericArguments()	Returnerar en matris med Type objekt som representerar typargumenten för en generisk metod eller typparametrarna för en generisk metoddefinition. (Ärvd från MethodInfo)
GetGenericMethodDefinition()	Returnerar ett MethodInfo objekt som representerar en allmän metoddefinition som den aktuella metoden kan konstrueras från. (Ärvd från MethodInfo)
GetHashCode()	Returnerar hash-koden för den här instansen. (Ärvd från MethodInfo)
GetILGenerator()	Returnerar en msil-generator (Microsoft mellanliggande språk) för metoden med en msil-standardströmstorlek på 64 byte.
GetILGenerator(Int32)	Returnerar en msil-generator (Microsoft mellanliggande språk) för metoden med den angivna MSIL-strömstorleken.
GetMethodBody()	När det åsidosätts i en härledd klass hämtar ett MethodBody objekt som ger åtkomst till MSIL-strömmen, lokala variabler och undantag för den aktuella metoden. (Ärvd från MethodBase)
GetMethodImplementationFlags()	Returnerar implementeringsflaggor för metoden.
GetParameters()	Returnerar parametrarna för den dynamiska metoden.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Anropar den dynamiska metoden med de angivna parametrarna, under begränsningarna för det angivna bindemedlet, med den angivna kulturinformationen.
IsDefined(Type, Boolean)	Anger om den angivna anpassade attributtypen har definierats.
MakeGenericMethod(Type[])	Ersätter elementen i en matris med typer för typparametrarna i den aktuella generiska metoddefinitionen och returnerar ett MethodInfo objekt som representerar den resulterande konstruerade metoden. (Ärvd från MethodInfo)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
ToString()	Returnerar signaturen för metoden, som representeras som en sträng.

Explicita gränssnittsimplementeringar

Name	Description
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare. (Ärvd från MemberInfo)
_MemberInfo.GetType()	Hämtar ett Type objekt som representerar MemberInfo klassen. (Ärvd från MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som sedan kan användas för att hämta typinformationen för ett gränssnitt. (Ärvd från MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1). (Ärvd från MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt. (Ärvd från MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare. (Ärvd från MethodBase)
_MethodBase.GetType()	En beskrivning av den här medlemmen finns i GetType(). (Ärvd från MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som sedan kan användas för att hämta typinformationen för ett gränssnitt. (Ärvd från MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1). (Ärvd från MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt. (Ärvd från MethodBase)
_MethodBase.IsAbstract	En beskrivning av den här medlemmen finns i IsAbstract. (Ärvd från MethodBase)
_MethodBase.IsAssembly	En beskrivning av den här medlemmen finns i IsAssembly. (Ärvd från MethodBase)
_MethodBase.IsConstructor	En beskrivning av den här medlemmen finns i IsConstructor. (Ärvd från MethodBase)
_MethodBase.IsFamily	En beskrivning av den här medlemmen finns i IsFamily. (Ärvd från MethodBase)
_MethodBase.IsFamilyAndAssembly	En beskrivning av den här medlemmen finns i IsFamilyAndAssembly. (Ärvd från MethodBase)
_MethodBase.IsFamilyOrAssembly	En beskrivning av den här medlemmen finns i IsFamilyOrAssembly. (Ärvd från MethodBase)
_MethodBase.IsFinal	En beskrivning av den här medlemmen finns i IsFinal. (Ärvd från MethodBase)
_MethodBase.IsHideBySig	En beskrivning av den här medlemmen finns i IsHideBySig. (Ärvd från MethodBase)
_MethodBase.IsPrivate	En beskrivning av den här medlemmen finns i IsPrivate. (Ärvd från MethodBase)
_MethodBase.IsPublic	En beskrivning av den här medlemmen finns i IsPublic. (Ärvd från MethodBase)
_MethodBase.IsSpecialName	En beskrivning av den här medlemmen finns i IsSpecialName. (Ärvd från MethodBase)
_MethodBase.IsStatic	En beskrivning av den här medlemmen finns i IsStatic. (Ärvd från MethodBase)
_MethodBase.IsVirtual	En beskrivning av den här medlemmen finns i IsVirtual. (Ärvd från MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare. (Ärvd från MethodInfo)
_MethodInfo.GetType()	Ger åtkomst till GetType() metoden från COM. (Ärvd från MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som kan användas för att hämta typinformationen för ett gränssnitt. (Ärvd från MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1). (Ärvd från MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt. (Ärvd från MethodInfo)

Tilläggsmetoder

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade objekt.
GetCustomAttribute(MemberInfo, Type)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttribute<T>(MemberInfo, Boolean)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade objekt.
GetCustomAttribute<T>(MemberInfo)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttributes(MemberInfo, Boolean)	Hämtar en samling anpassade attribut som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes(MemberInfo, Type, Boolean)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes(MemberInfo, Type)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttributes(MemberInfo)	Hämtar en samling anpassade attribut som tillämpas på en angiven medlem.
GetCustomAttributes<T>(MemberInfo, Boolean)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes<T>(MemberInfo)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem.
GetRuntimeBaseDefinition(MethodInfo)	Hämtar ett objekt som representerar den angivna metoden i den direkta eller indirekta basklassen där metoden först deklarerades.
IsDefined(MemberInfo, Type, Boolean)	Anger om anpassade attribut av en angiven typ tillämpas på en angiven medlem och eventuellt tillämpas på dess överordnade.
IsDefined(MemberInfo, Type)	Anger om anpassade attribut av en angiven typ tillämpas på en angiven medlem.

Se även

• Anvisningar: Definiera och köra dynamiska metoder
• säkerhetsproblem i Reflection Emit
• Genomgång: Generera kod i partiella förtroendescenarier