ConstructorBuilder Klas

Definitie

Naamruimte:

System.Reflection.Emit

Assembly:

mscorlib.dll

Definieert en vertegenwoordigt een constructor van een dynamische klasse.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _ConstructorBuilder

Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder

Overname

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

Kenmerken

ClassInterfaceAttribute ComVisibleAttribute

Implementeringen

_ConstructorBuilder

Voorbeelden

Het volgende codevoorbeeld illustreert het contextuele gebruik van een ConstructorBuilder.

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

class TestCtorBuilder {

    public static Type DynamicPointTypeGen() {
    
       Type pointType = null;
       Type[] ctorParams = new Type[] {typeof(int),
                        typeof(int),
                        typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "MyDynamicAssembly";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.RunAndSave);

       ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                    "Point.dll");

       TypeBuilder pointTypeBld = pointModule.DefineType("Point",
                                      TypeAttributes.Public);

       FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
                                                          FieldAttributes.Public);
       FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
                                                          FieldAttributes.Public);
       FieldBuilder zField = pointTypeBld.DefineField("z", typeof(int),
                                                          FieldAttributes.Public);

           Type objType = Type.GetType("System.Object");
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = pointCtor.GetILGenerator();

       // NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
       // hold the actual passed parameters. ldarg.0 is used by instance methods
       // to hold a reference to the current calling object instance. Static methods
       // do not use arg.0, since they are not instantiated and hence no reference
       // is needed to distinguish them.

           ctorIL.Emit(OpCodes.Ldarg_0);

       // Here, we wish to create an instance of System.Object by invoking its
       // constructor, as specified above.

           ctorIL.Emit(OpCodes.Call, objCtor);

       // Now, we'll load the current instance ref in arg 0, along
       // with the value of parameter "x" stored in arg 1, into stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField);

       // Now, we store arg 2 "y" in the current instance with stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField);

       // Last of all, arg 3 "z" gets stored in the current instance.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField);

           // Our work complete, we return.

       ctorIL.Emit(OpCodes.Ret);

       // Now, let's create three very simple methods so we can see our fields.

       string[] mthdNames = new string[] {"GetX", "GetY", "GetZ"};

           foreach (string mthdName in mthdNames) {
              MethodBuilder getFieldMthd = pointTypeBld.DefineMethod(
                           mthdName,
                           MethodAttributes.Public,
                                           typeof(int),
                                           null);
          ILGenerator mthdIL = getFieldMthd.GetILGenerator();
    
          mthdIL.Emit(OpCodes.Ldarg_0);
          switch (mthdName) {
             case "GetX": mthdIL.Emit(OpCodes.Ldfld, xField);
                  break;
             case "GetY": mthdIL.Emit(OpCodes.Ldfld, yField);
                  break;
             case "GetZ": mthdIL.Emit(OpCodes.Ldfld, zField);
                  break;
          }
          mthdIL.Emit(OpCodes.Ret);
           }
       // Finally, we create the type.

       pointType = pointTypeBld.CreateType();

       // Let's save it, just for posterity.
    
       myAsmBuilder.Save("Point.dll");
    
       return pointType;
    }

    public static void Main() {
    
       Type myDynamicType = null;
           object aPoint = null;
       Type[] aPtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aPargs = new object[] {4, 5, 6};
    
       // Call the  method to build our dynamic class.

       myDynamicType = DynamicPointTypeGen();

       Console.WriteLine("Some information about my new Type '{0}':",
                  myDynamicType.FullName);
       Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly);
       Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes);
       Console.WriteLine("Module: '{0}'", myDynamicType.Module);
       Console.WriteLine("Members: ");
       foreach (MemberInfo member in myDynamicType.GetMembers()) {
        Console.WriteLine("-- {0} {1};", member.MemberType, member.Name);
       }

           Console.WriteLine("---");

       // Let's take a look at the constructor we created.

       ConstructorInfo myDTctor = myDynamicType.GetConstructor(aPtypes);
           Console.WriteLine("Constructor: {0};", myDTctor.ToString());

           Console.WriteLine("---");
    
           // Now, we get to use our dynamically-created class by invoking the constructor.

       aPoint = myDTctor.Invoke(aPargs);
           Console.WriteLine("aPoint is type {0}.", aPoint.GetType());

       // Finally, let's reflect on the instance of our new type - aPoint - and
       // make sure everything proceeded according to plan.

       Console.WriteLine("aPoint.x = {0}",
                 myDynamicType.InvokeMember("GetX",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.y = {0}",
                 myDynamicType.InvokeMember("GetY",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.z = {0}",
                 myDynamicType.InvokeMember("GetZ",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));

       // +++ OUTPUT +++
       // Some information about my new Type 'Point':
       // Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
       // Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
       // Module: 'PointModule'
       // Members:
       // -- Field x;
       // -- Field y;
       // -- Field z;
           // -- Method GetHashCode;
           // -- Method Equals;
           // -- Method ToString;
           // -- Method GetType;
           // -- Constructor .ctor;
       // ---
       // Constructor: Void .ctor(Int32, Int32, Int32);
       // ---
       // aPoint is type Point.
       // aPoint.x = 4
       // aPoint.y = 5
       // aPoint.z = 6
    }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class TestCtorBuilder
   
   
   Public Shared Function DynamicPointTypeGen() As Type
      
      Dim pointType As Type = Nothing
      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      
      Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
      
      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", GetType(Integer), FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", GetType(Integer), FieldAttributes.Public)
      Dim zField As FieldBuilder = pointTypeBld.DefineField("z", GetType(Integer), FieldAttributes.Public)
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      
      ' NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
      ' hold the actual passed parameters. ldarg.0 is used by instance methods
      ' to hold a reference to the current calling object instance. Static methods
      ' do not use arg.0, since they are not instantiated and hence no reference
      ' is needed to distinguish them. 
      ctorIL.Emit(OpCodes.Ldarg_0)
      
      ' Here, we wish to create an instance of System.Object by invoking its
      ' constructor, as specified above.
      ctorIL.Emit(OpCodes.Call, objCtor)
      
      ' Now, we'll load the current instance ref in arg 0, along
      ' with the value of parameter "x" stored in arg 1, into stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      
      ' Now, we store arg 2 "y" in the current instance with stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      
      ' Last of all, arg 3 "z" gets stored in the current instance.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      
      ' Our work complete, we return.
      ctorIL.Emit(OpCodes.Ret)
      
      ' Now, let's create three very simple methods so we can see our fields.
      Dim mthdNames() As String = {"GetX", "GetY", "GetZ"}
      
      Dim mthdName As String
      For Each mthdName In  mthdNames
         Dim getFieldMthd As MethodBuilder = pointTypeBld.DefineMethod(mthdName, MethodAttributes.Public, GetType(Integer), Nothing)
         Dim mthdIL As ILGenerator = getFieldMthd.GetILGenerator()
         
         mthdIL.Emit(OpCodes.Ldarg_0)
         Select Case mthdName
            Case "GetX"
               mthdIL.Emit(OpCodes.Ldfld, xField)
            Case "GetY"
               mthdIL.Emit(OpCodes.Ldfld, yField)
            Case "GetZ"
               mthdIL.Emit(OpCodes.Ldfld, zField)
         End Select
         
         mthdIL.Emit(OpCodes.Ret)
      Next mthdName 
      ' Finally, we create the type.
      pointType = pointTypeBld.CreateType()
      
      ' Let's save it, just for posterity.
      myAsmBuilder.Save("Point.dll")
      
      Return pointType
   End Function 'DynamicPointTypeGen
    
   
   Public Shared Sub Main()
      
      Dim myDynamicType As Type = Nothing
      Dim aPoint As Object = Nothing
      Dim aPtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aPargs() As Object = {4, 5, 6}
      
      ' Call the  method to build our dynamic class.
      myDynamicType = DynamicPointTypeGen()
      
      Console.WriteLine("Some information about my new Type '{0}':", myDynamicType.FullName)
      Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly)
      Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes)
      Console.WriteLine("Module: '{0}'", myDynamicType.Module)
      Console.WriteLine("Members: ")
      Dim member As MemberInfo
      For Each member In  myDynamicType.GetMembers()
         Console.WriteLine("-- {0} {1};", member.MemberType, member.Name)
      Next member
      
      Console.WriteLine("---")
      
      ' Let's take a look at the constructor we created.
      Dim myDTctor As ConstructorInfo = myDynamicType.GetConstructor(aPtypes)
      Console.WriteLine("Constructor: {0};", myDTctor.ToString())
      
      Console.WriteLine("---")
      
      ' Now, we get to use our dynamically-created class by invoking the constructor. 
      aPoint = myDTctor.Invoke(aPargs)
      Console.WriteLine("aPoint is type {0}.", aPoint.GetType())
      
      
      ' Finally, let's reflect on the instance of our new type - aPoint - and
      ' make sure everything proceeded according to plan.
      Console.WriteLine("aPoint.x = {0}", myDynamicType.InvokeMember("GetX", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.y = {0}", myDynamicType.InvokeMember("GetY", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.z = {0}", myDynamicType.InvokeMember("GetZ", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
   End Sub
End Class



' +++ OUTPUT +++
' Some information about my new Type 'Point':
' Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
' Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
' Module: 'PointModule'
' Members: 
' -- Field x;
' -- Field y;
' -- Field z;
' -- Method GetHashCode;
' -- Method Equals;
' -- Method ToString;
' -- Method GetType;
' -- Constructor .ctor;
' ---
' Constructor: Void .ctor(Int32, Int32, Int32);
' ---
' aPoint is type Point.
' aPoint.x = 4
' aPoint.y = 5
' aPoint.z = 6

Opmerkingen

ConstructorBuilder wordt gebruikt om een constructor volledig te beschrijven in Microsoft tussentaal (MSIL), inclusief de naam, kenmerken, handtekening en constructortekst. Deze wordt gebruikt in combinatie met de TypeBuilder klasse om klassen tijdens runtime te maken. Aanroep DefineConstructor om een exemplaar van ConstructorBuilder.

Als u geen constructor definieert voor uw dynamische type, wordt er automatisch een parameterloze constructor opgegeven en wordt de parameterloze constructor van de basisklasse aanroepen.

Als u ConstructorBuilder een constructor voor uw dynamische type definieert, wordt er geen parameterloze constructor opgegeven. U hebt de volgende opties voor het opgeven van een parameterloze constructor naast de constructor die u hebt gedefinieerd:

• Als u een parameterloze constructor wilt die simpelweg de parameterloze constructor van de basisklasse aanroept, kunt u de TypeBuilder.DefineDefaultConstructor methode gebruiken om er een te maken (en eventueel de toegang tot de klasse te beperken). Geef geen implementatie op voor deze parameterloze constructor. Als u dit doet, wordt er een uitzondering gegenereerd wanneer u de constructor probeert te gebruiken. Er wordt geen uitzondering gegenereerd wanneer de TypeBuilder.CreateType methode wordt aangeroepen.

• Als u een parameterloze constructor wilt die meer doet dan alleen de parameterloze constructor van de basisklasse aanroepen, of die een andere constructor van de basisklasse aanroept, of die iets anders doet, moet u de TypeBuilder.DefineConstructor methode gebruiken om een ConstructorBuilder, en uw eigen implementatie te maken.

Eigenschappen

Name	Description
Attributes	Haalt de kenmerken voor deze constructor op.
CallingConvention	Hiermee haalt u een CallingConventions waarde op die afhankelijk is van of het declaratietype algemeen is.
ContainsGenericParameters	Hiermee wordt een waarde opgehaald die aangeeft of de algemene methode niet-toegewezen algemene typeparameters bevat. (Overgenomen van MethodBase)
CustomAttributes	Hiermee haalt u een verzameling op die de aangepaste kenmerken van dit lid bevat. (Overgenomen van MemberInfo)
DeclaringType	Hiermee wordt een verwijzing naar het Type object opgehaald voor het type dat dit lid declareert.
InitLocals	Hiermee wordt aangegeven of de lokale variabelen in deze constructor nul moeten worden geïnitialiseerd.
IsAbstract	Hiermee wordt een waarde opgehaald die aangeeft of de methode abstract is. (Overgenomen van MethodBase)
IsAssembly	Hiermee wordt een waarde opgehaald die aangeeft of de mogelijke zichtbaarheid van deze methode of constructor wordt beschreven door Assembly; dat wil zeggen dat de methode of constructor maximaal zichtbaar is voor andere typen in dezelfde assembly en niet zichtbaar is voor afgeleide typen buiten de assembly. (Overgenomen van MethodBase)
IsConstructor	Hiermee wordt een waarde opgehaald die aangeeft of de methode een constructor is. (Overgenomen van MethodBase)
IsFamily	Hiermee wordt een waarde opgehaald die aangeeft of de zichtbaarheid van deze methode of constructor wordt beschreven door Family; dat wil zeggen dat de methode of constructor alleen zichtbaar is binnen de klasse en afgeleide klassen. (Overgenomen van MethodBase)
IsFamilyAndAssembly	Hiermee wordt een waarde opgehaald die aangeeft of de zichtbaarheid van deze methode of constructor wordt beschreven door FamANDAssem; dat wil zeggen, de methode of constructor kan worden aangeroepen door afgeleide klassen, maar alleen als deze zich in dezelfde assembly bevinden. (Overgenomen van MethodBase)
IsFamilyOrAssembly	Hiermee wordt een waarde opgehaald die aangeeft of de mogelijke zichtbaarheid van deze methode of constructor wordt beschreven door FamORAssem; dat wil zeggen, de methode of constructor kan worden aangeroepen door afgeleide klassen waar ze zich ook bevinden en door klassen in dezelfde assembly. (Overgenomen van MethodBase)
IsFinal	Hiermee wordt een waarde opgehaald die aangeeft of deze methode is final. (Overgenomen van MethodBase)
IsGenericMethod	Hiermee wordt een waarde opgehaald die aangeeft of de methode algemeen is. (Overgenomen van MethodBase)
IsGenericMethodDefinition	Hiermee wordt een waarde opgehaald die aangeeft of de methode een algemene methodedefinitie is. (Overgenomen van MethodBase)
IsHideBySig	Hiermee wordt een waarde opgehaald die aangeeft of alleen een lid van hetzelfde type met exact dezelfde handtekening is verborgen in de afgeleide klasse. (Overgenomen van MethodBase)
IsPrivate	Hiermee wordt een waarde opgehaald die aangeeft of dit lid privé is. (Overgenomen van MethodBase)
IsPublic	Hiermee wordt een waarde opgehaald die aangeeft of dit een openbare methode is. (Overgenomen van MethodBase)
IsSecurityCritical	Hiermee wordt een waarde opgehaald die aangeeft of de huidige methode of constructor beveiligingskritiek of veilig is op het huidige vertrouwensniveau en daarom kritieke bewerkingen kan uitvoeren. (Overgenomen van MethodBase)
IsSecuritySafeCritical	Hiermee wordt een waarde opgehaald die aangeeft of de huidige methode of constructor beveiligingsveilig is op het huidige vertrouwensniveau; dat wil gezegd, of het kritieke bewerkingen kan uitvoeren en toegankelijk is via transparante code. (Overgenomen van MethodBase)
IsSecurityTransparent	Hiermee wordt een waarde opgehaald die aangeeft of de huidige methode of constructor transparant is op het huidige vertrouwensniveau en daarom geen kritieke bewerkingen kan uitvoeren. (Overgenomen van MethodBase)
IsSpecialName	Hiermee wordt een waarde opgehaald die aangeeft of deze methode een speciale naam heeft. (Overgenomen van MethodBase)
IsStatic	Hiermee wordt een waarde opgehaald die aangeeft of de methode is static. (Overgenomen van MethodBase)
IsVirtual	Hiermee wordt een waarde opgehaald die aangeeft of de methode is virtual. (Overgenomen van MethodBase)
MemberType	Hiermee wordt een MemberTypes waarde opgehaald die aangeeft dat dit lid een constructor is. (Overgenomen van ConstructorInfo)
MetadataToken	Hiermee haalt u een waarde op waarmee een metagegevenselement wordt geïdentificeerd. (Overgenomen van MemberInfo)
MethodHandle	Hiermee haalt u de interne ingang voor de methode op. Gebruik deze ingang voor toegang tot de onderliggende metagegevensgreep.
MethodImplementationFlags	Hiermee haalt u de MethodImplAttributes vlaggen op die de kenmerken van een methode-implementatie opgeven. (Overgenomen van MethodBase)
Module	Hiermee haalt u de dynamische module op waarin deze constructor is gedefinieerd.
Name	Haalt de naam van deze constructor op.
ReflectedType	Bevat een verwijzing naar het Type object waaruit dit object is verkregen.
ReturnType	Verouderd. Krijgt null.
Signature	Haalt de handtekening van het veld op in de vorm van een tekenreeks.

Methoden

Name	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Voegt declaratieve beveiliging toe aan deze constructor.
DefineParameter(Int32, ParameterAttributes, String)	Hiermee definieert u een parameter van deze constructor.
Equals(Object)	Retourneert een waarde die aangeeft of dit exemplaar gelijk is aan een opgegeven object. (Overgenomen van ConstructorInfo)
GetCustomAttributes(Boolean)	Retourneert alle aangepaste kenmerken die zijn gedefinieerd voor deze constructor.
GetCustomAttributes(Type, Boolean)	Retourneert de aangepaste kenmerken die zijn geïdentificeerd door het opgegeven type.
GetCustomAttributesData()	Retourneert een lijst CustomAttributeData met objecten die gegevens vertegenwoordigen over de kenmerken die zijn toegepast op het doellid. (Overgenomen van MemberInfo)
GetGenericArguments()	Retourneert een matrix met Type objecten die de typeargumenten van een algemene methode of de typeparameters van een algemene methodedefinitie vertegenwoordigen. (Overgenomen van MethodBase)
GetHashCode()	Retourneert de hash-code voor dit exemplaar. (Overgenomen van ConstructorInfo)
GetILGenerator()	Hiermee haalt u een ILGenerator voor deze constructor op.
GetILGenerator(Int32)	Hiermee haalt u een ILGenerator object op met de opgegeven MSIL-stroomgrootte die kan worden gebruikt om een methodebody voor deze constructor te bouwen.
GetMethodBody()	Wanneer deze wordt overschreven in een afgeleide klasse, haalt u een MethodBody object op dat toegang biedt tot de MSIL-stroom, lokale variabelen en uitzonderingen voor de huidige methode. (Overgenomen van MethodBase)
GetMethodImplementationFlags()	Retourneert de implementatievlagmen voor de methode voor deze constructor.
GetModule()	Retourneert een verwijzing naar de module die deze constructor bevat.
GetParameters()	Retourneert de parameters van deze constructor.
GetToken()	Retourneert het MethodToken token voor deze constructor.
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Roept dynamisch de constructor aan die wordt vertegenwoordigd door dit exemplaar op het opgegeven object, waarbij de opgegeven parameters worden doorgegeven en onder de beperkingen van de opgegeven binder.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Roept de constructor dynamisch aan die door dit exemplaar wordt weerspiegeld met de opgegeven argumenten, onder de beperkingen van de opgegeven Binder.
Invoke(Object, Object[])	Roept de methode of constructor aan die wordt vertegenwoordigd door het huidige exemplaar, met behulp van de opgegeven parameters. (Overgenomen van MethodBase)
Invoke(Object[])	Roept de constructor aan die wordt weerspiegeld door het exemplaar met de opgegeven parameters, waarbij standaardwaarden worden opgegeven voor de parameters die niet vaak worden gebruikt. (Overgenomen van ConstructorInfo)
IsDefined(Type, Boolean)	Controleert of het opgegeven aangepaste kenmerktype is gedefinieerd.
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Stel een aangepast kenmerk in met behulp van een opgegeven aangepaste kenmerk-blob.
SetCustomAttribute(CustomAttributeBuilder)	Stel een aangepast kenmerk in met behulp van een opbouwfunctie voor aangepaste kenmerken.
SetImplementationFlags(MethodImplAttributes)	Hiermee stelt u de implementatievlagken voor de methode voor deze constructor in.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Hiermee maakt u de hoofdtekst van de constructor met behulp van een opgegeven bytematrix van Microsoft tussenliggende taalinstructies (MSIL).
SetSymCustomAttribute(String, Byte[])	Hiermee stelt u het aangepaste kenmerk van deze constructor in dat is gekoppeld aan symbolische informatie.
ToString()	Retourneert dit ConstructorBuilder exemplaar als een String.

Expliciete interface-implementaties

Name	Description
_ConstructorBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Hiermee wordt een set namen toegewezen aan een bijbehorende set verzend-id's.
_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Haalt de typegegevens voor een object op, die vervolgens kan worden gebruikt om de typegegevens voor een interface op te halen.
_ConstructorBuilder.GetTypeInfoCount(UInt32)	Hiermee wordt het aantal type-informatieinterfaces opgehaald dat een object biedt (0 of 1).
_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Biedt toegang tot eigenschappen en methoden die door een object worden weergegeven.
_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Hiermee wordt een set namen toegewezen aan een bijbehorende set verzend-id's. (Overgenomen van ConstructorInfo)
_ConstructorInfo.GetType()	Hiermee wordt een Type object opgehaald dat het ConstructorInfo type vertegenwoordigt. (Overgenomen van ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Haalt de typegegevens voor een object op, die vervolgens kan worden gebruikt om de typegegevens voor een interface op te halen. (Overgenomen van ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)	Hiermee wordt het aantal type-informatieinterfaces opgehaald dat een object biedt (0 of 1). (Overgenomen van ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)	Biedt COM-objecten met versie-onafhankelijke toegang tot de Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) methode. (Overgenomen van ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])	Biedt COM-objecten met versie-onafhankelijke toegang tot de Invoke(Object, Object[]) methode. (Overgenomen van ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)	Biedt COM-objecten met versie-onafhankelijke toegang tot de Invoke(BindingFlags, Binder, Object[], CultureInfo) methode. (Overgenomen van ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])	Biedt COM-objecten met versie-onafhankelijke toegang tot de Invoke(Object[]) methode. (Overgenomen van ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Biedt toegang tot eigenschappen en methoden die door een object worden weergegeven. (Overgenomen van ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Hiermee wordt een set namen toegewezen aan een bijbehorende set verzend-id's. (Overgenomen van MemberInfo)
_MemberInfo.GetType()	Hiermee haalt u een Type object op dat de MemberInfo klasse vertegenwoordigt. (Overgenomen van MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Haalt de typegegevens voor een object op, die vervolgens kan worden gebruikt om de typegegevens voor een interface op te halen. (Overgenomen van MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Hiermee wordt het aantal type-informatieinterfaces opgehaald dat een object biedt (0 of 1). (Overgenomen van MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Biedt toegang tot eigenschappen en methoden die door een object worden weergegeven. (Overgenomen van MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Hiermee wordt een set namen toegewezen aan een bijbehorende set verzend-id's. (Overgenomen van MethodBase)
_MethodBase.GetType()	Zie voor een beschrijving van dit lid GetType(). (Overgenomen van MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Haalt de typegegevens voor een object op, die vervolgens kan worden gebruikt om de typegegevens voor een interface op te halen. (Overgenomen van MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Hiermee wordt het aantal type-informatieinterfaces opgehaald dat een object biedt (0 of 1). (Overgenomen van MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Biedt toegang tot eigenschappen en methoden die door een object worden weergegeven. (Overgenomen van MethodBase)
_MethodBase.IsAbstract	Zie voor een beschrijving van dit lid IsAbstract. (Overgenomen van MethodBase)
_MethodBase.IsAssembly	Zie voor een beschrijving van dit lid IsAssembly. (Overgenomen van MethodBase)
_MethodBase.IsConstructor	Zie voor een beschrijving van dit lid IsConstructor. (Overgenomen van MethodBase)
_MethodBase.IsFamily	Zie voor een beschrijving van dit lid IsFamily. (Overgenomen van MethodBase)
_MethodBase.IsFamilyAndAssembly	Zie voor een beschrijving van dit lid IsFamilyAndAssembly. (Overgenomen van MethodBase)
_MethodBase.IsFamilyOrAssembly	Zie voor een beschrijving van dit lid IsFamilyOrAssembly. (Overgenomen van MethodBase)
_MethodBase.IsFinal	Zie voor een beschrijving van dit lid IsFinal. (Overgenomen van MethodBase)
_MethodBase.IsHideBySig	Zie voor een beschrijving van dit lid IsHideBySig. (Overgenomen van MethodBase)
_MethodBase.IsPrivate	Zie voor een beschrijving van dit lid IsPrivate. (Overgenomen van MethodBase)
_MethodBase.IsPublic	Zie voor een beschrijving van dit lid IsPublic. (Overgenomen van MethodBase)
_MethodBase.IsSpecialName	Zie voor een beschrijving van dit lid IsSpecialName. (Overgenomen van MethodBase)
_MethodBase.IsStatic	Zie voor een beschrijving van dit lid IsStatic. (Overgenomen van MethodBase)
_MethodBase.IsVirtual	Zie voor een beschrijving van dit lid IsVirtual. (Overgenomen van MethodBase)

Extensiemethoden

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Haalt een aangepast kenmerk op van een opgegeven type dat wordt toegepast op een opgegeven lid en inspecteert eventueel de voorouders van dat lid.
GetCustomAttribute(MemberInfo, Type)	Hiermee wordt een aangepast kenmerk opgehaald van een opgegeven type dat wordt toegepast op een opgegeven lid.
GetCustomAttribute<T>(MemberInfo, Boolean)	Haalt een aangepast kenmerk op van een opgegeven type dat wordt toegepast op een opgegeven lid en inspecteert eventueel de voorouders van dat lid.
GetCustomAttribute<T>(MemberInfo)	Hiermee wordt een aangepast kenmerk opgehaald van een opgegeven type dat wordt toegepast op een opgegeven lid.
GetCustomAttributes(MemberInfo, Boolean)	Haalt een verzameling aangepaste kenmerken op die worden toegepast op een opgegeven lid en inspecteert eventueel de voorouders van dat lid.
GetCustomAttributes(MemberInfo, Type, Boolean)	Haalt een verzameling aangepaste kenmerken op van een opgegeven type dat wordt toegepast op een opgegeven lid en inspecteert eventueel de voorouders van dat lid.
GetCustomAttributes(MemberInfo, Type)	Hiermee wordt een verzameling aangepaste kenmerken opgehaald van een opgegeven type dat wordt toegepast op een opgegeven lid.
GetCustomAttributes(MemberInfo)	Hiermee haalt u een verzameling aangepaste kenmerken op die worden toegepast op een opgegeven lid.
GetCustomAttributes<T>(MemberInfo, Boolean)	Haalt een verzameling aangepaste kenmerken op van een opgegeven type dat wordt toegepast op een opgegeven lid en inspecteert eventueel de voorouders van dat lid.
GetCustomAttributes<T>(MemberInfo)	Hiermee wordt een verzameling aangepaste kenmerken opgehaald van een opgegeven type dat wordt toegepast op een opgegeven lid.
IsDefined(MemberInfo, Type, Boolean)	Hiermee wordt aangegeven of aangepaste kenmerken van een opgegeven type worden toegepast op een opgegeven lid, en eventueel toegepast op de bovenliggende kenmerken.
IsDefined(MemberInfo, Type)	Hiermee wordt aangegeven of aangepaste kenmerken van een opgegeven type worden toegepast op een opgegeven lid.