MethodBuilder Klass

Definition

Namnområde:: System.Reflection.Emit

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Definierar och representerar en metod (eller konstruktor) i en dynamisk klass.

public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder

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

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder

public sealed class MethodBuilder : System.Reflection.MethodInfo

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder

type MethodBuilder = class
    inherit MethodInfo

Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder

Public NotInheritable Class MethodBuilder
Inherits MethodInfo

Arv: Object

MemberInfo

MethodBase

MethodInfo
MethodBuilder

Attribut: ClassInterfaceAttribute ComVisibleAttribute

Implementeringar: _MethodBuilder

Exempel

I följande exempel används MethodBuilder klassen för att skapa en metod inom en dynamisk typ.


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

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

Kommentarer

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

Egenskaper

Name	Description
Attributes	Hämtar attributen för den här metoden.
CallingConvention	Returnerar metodens anropande konvention.
ContainsGenericParameters	Stöds inte för den här typen.
CustomAttributes	Hämtar en samling som innehåller den här medlemmens anpassade attribut. (Ärvd från MemberInfo)
DeclaringType	Returnerar den typ som deklarerar den här metoden.
InitLocals	Hämtar eller anger ett booleskt värde som anger om de lokala variablerna i den här metoden är nollinitierade. Standardvärdet för den här egenskapen är `true`.
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)
IsConstructedGenericMethod	Definierar och representerar en metod (eller konstruktor) i en dynamisk klass.
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)
IsGenericMethod	Hämtar ett värde som anger om metoden är en allmän metod.
IsGenericMethodDefinition	Hämtar ett värde som anger om det aktuella MethodBuilder objektet representerar definitionen av en allmän metod.
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	Kastar en NotSupportedException i alla fall.
IsSecurityCritical	Hämtar ett värde som anger om den aktuella metoden eller konstruktorn är säkerhetskritisk eller säkerhetssäker på den aktuella förtroendenivån och därför kan utföra kritiska åtgärder. (Ärvd från MethodBase)
IsSecuritySafeCritical	Kastar en NotSupportedException i alla fall.
IsSecuritySafeCritical	Hämtar ett värde som anger om den aktuella metoden eller konstruktorn ä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. (Ärvd från MethodBase)
IsSecurityTransparent	Kastar en NotSupportedException i alla fall.
IsSecurityTransparent	Hämtar ett värde som anger om den aktuella metoden eller konstruktorn är transparent på den aktuella förtroendenivån och därför inte kan utföra kritiska åtgärder. (Ärvd från MethodBase)
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	Hämtar det interna handtaget för metoden. Använd den här referensen för att komma åt det underliggande metadatahandtaget.
MethodImplementationFlags	MethodImplAttributes Hämtar flaggorna som anger attributen för en metodimplementering. (Ärvd från MethodBase)
Module	Hämtar modulen där den aktuella metoden definieras.
Name	Hämtar namnet på den här metoden.
ReflectedType	Hämtar klassen som användes i reflektion för att hämta det här objektet.
ReturnParameter	Hämtar ett ParameterInfo objekt som innehåller information om metodens returtyp, till exempel om returtypen har anpassade modifierare.
ReturnType	Hämtar returtypen för metoden som representeras av den här MethodBuilder.
ReturnType	Hämtar returtypen för den här metoden. (Ärvd från MethodInfo)
ReturnTypeCustomAttributes	Returnerar de anpassade attributen för metodens returtyp.
Signature	Hämtar metodens signatur.

Metoder

Name	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Lägger till deklarativ säkerhet i den här metoden.
CreateDelegate(Type, Object)	Skapar ett ombud av den angivna typen med det angivna målet från den här metoden. (Ärvd från MethodInfo)
CreateDelegate(Type)	Skapar ett ombud av den angivna typen från den här metoden. (Ärvd från MethodInfo)
CreateMethodBody(Byte[], Int32)	Skapar metodens brödtext med hjälp av en angiven bytematris med instruktioner för Microsoft mellanliggande språk (MSIL).
DefineGenericParameters(String[])	Anger antalet generiska typparametrar för den aktuella metoden, anger deras namn och returnerar en matris med GenericTypeParameterBuilder objekt som kan användas för att definiera deras begränsningar.
DefineParameter(Int32, ParameterAttributes, String)	Anger parameterattributen och namnet på en parameter för den här metoden eller returvärdet för den här metoden. Returnerar en ParameterBuilder som kan användas för att tillämpa anpassade attribut.
Equals(Object)	Avgör om det angivna objektet är lika med den här instansen.
GetBaseDefinition()	Returnera basimplementeringen för en metod.
GetCustomAttributes(Boolean)	Returnerar alla anpassade attribut som definierats för den här metoden.
GetCustomAttributes(Type, Boolean)	Returnerar de anpassade attribut som identifieras av den angivna typen.
GetCustomAttributesData()	Returnerar en lista över CustomAttributeData objekt som representerar data om de attribut som har tillämpats på målmedlemmen. (Ärvd från MemberInfo)
GetGenericArguments()	Returnerar en matris med GenericTypeParameterBuilder objekt som representerar metodens typparametrar, om den är generisk.
GetGenericMethodDefinition()	Returnerar den här metoden.
GetHashCode()	Hämtar hash-koden för den här metoden.
GetILGenerator()	Returnerar en `ILGenerator` för den här metoden med en standardströmstorlek på 64 byte Microsoft mellanliggande språk (MSIL).
GetILGenerator(Int32)	Returnerar en `ILGenerator` för den här metoden med angiven msil-strömstorlek (Microsoft mellanliggande språk).
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.
GetModule()	Returnerar en referens till modulen som innehåller den här metoden.
GetParameters()	Returnerar parametrarna för den här metoden.
GetToken()	`MethodToken` Returnerar som representerar token för den här metoden.
GetType()	Identifierar attributen för en metod och ger åtkomst till metodmetadata. (Ärvd från MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Definierar och representerar en metod (eller konstruktor) i en dynamisk klass. (Ärvd från MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Anropar dynamiskt den metod som återspeglas av den här instansen på det angivna objektet, skickar längs de angivna parametrarna och under begränsningarna för det angivna bindemedlet.
Invoke(Object, Object[])	Anropar metoden eller konstruktorn som representeras av den aktuella instansen med hjälp av de angivna parametrarna. (Ärvd från MethodInfo)
IsDefined(Type, Boolean)	Kontrollerar om den angivna anpassade attributtypen har definierats.
MakeGenericMethod(Type[])	Returnerar en generisk metod som konstruerats från den aktuella generiska metoddefinitionen med hjälp av de angivna allmänna typargumenten.
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Anger ett anpassat attribut med en angiven anpassad attributblob.
SetCustomAttribute(CustomAttributeBuilder)	Anger ett anpassat attribut med hjälp av en anpassad attributbyggare.
SetImplementationFlags(MethodImplAttributes)	Anger implementeringsflaggor för den här metoden.
SetMarshal(UnmanagedMarshal)	Föråldrad. Anger marshaling-information för returtypen för den här metoden.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Skapar metodens brödtext med hjälp av en angiven bytematris med instruktioner för Microsoft mellanliggande språk (MSIL).
SetParameters(Type[])	Anger antal och typer av parametrar för en metod.
SetReturnType(Type)	Anger metodens returtyp.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Anger metodsignaturen, inklusive returtyp, parametertyper och nödvändiga och valfria anpassade modifierare för returtypen och parametertyperna.
SetSymCustomAttribute(String, Byte[])	Ange ett symboliskt anpassat attribut med hjälp av en blob.
ToString()	Returnerar den här `MethodBuilder` instansen 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)
_MethodBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare.
_MethodBuilder.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.
_MethodBuilder.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1).
_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt.
_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.

Gäller för

Feedback

Var den här sidan till hjälp?