ConstructorBuilder Klasse

Definition

Namespace:: System.Reflection.Emit

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Definiert und stellt einen Konstruktor einer dynamischen Klasse dar.

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

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
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)]
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder

public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo

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

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

type ConstructorBuilder = class
    inherit ConstructorInfo

Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder

Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo

Vererbung: Object

MemberInfo

MethodBase

ConstructorInfo
ConstructorBuilder

Attribute: ClassInterfaceAttribute ComVisibleAttribute

Implementiert: _ConstructorBuilder

Beispiele

Das folgende Codebeispiel veranschaulicht die kontextbezogene Verwendung einer 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

Hinweise

ConstructorBuilder wird verwendet, um einen Konstruktor in Microsoft Zwischensprache (MSIL) vollständig zu beschreiben, einschließlich Name, Attribute, Signatur und Konstruktortext. Sie wird in Verbindung mit der TypeBuilder Klasse zum Erstellen von Klassen zur Laufzeit verwendet. Rufen Sie DefineConstructor auf, um eine Instanz von ConstructorBuilder.

Wenn Sie keinen Konstruktor für ihren dynamischen Typ definieren, wird automatisch ein parameterloser Konstruktor bereitgestellt, und er ruft den parameterlosen Konstruktor der Basisklasse auf.

Wenn Sie ConstructorBuilder einen Konstruktor für ihren dynamischen Typ definieren, wird kein parameterloser Konstruktor bereitgestellt. Sie haben die folgenden Optionen zum Bereitstellen eines parameterlosen Konstruktors zusätzlich zum von Ihnen definierten Konstruktor:

Wenn Sie einen parameterlosen Konstruktor benötigen, der einfach den parameterlosen Konstruktor der Basisklasse aufruft, können Sie die TypeBuilder.DefineDefaultConstructor Methode verwenden, um einen zu erstellen (und optional den Zugriff darauf einzuschränken). Stellen Sie keine Implementierung für diesen parameterlosen Konstruktor bereit. Wenn Sie dies tun, wird eine Ausnahme ausgelöst, wenn Sie versuchen, den Konstruktor zu verwenden. Es wird keine Ausnahme ausgelöst, wenn die TypeBuilder.CreateType Methode aufgerufen wird.
Wenn Sie einen parameterlosen Konstruktor benötigen, der nicht nur den parameterlosen Konstruktor der Basisklasse aufruft oder einen anderen Konstruktor der Basisklasse aufruft oder das etwas anderes erledigt, müssen Sie die TypeBuilder.DefineConstructor Methode verwenden, um eine ConstructorBuilder, und ihre eigene Implementierung bereitzustellen.

Eigenschaften

Name	Beschreibung
Attributes	Ruft die Attribute für diesen Konstruktor ab.
CallingConvention	Ruft einen CallingConventions Wert ab, der davon abhängt, ob der deklarierende Typ generisch ist.
CallingConvention	Ruft einen Wert ab, der die Aufrufkonventionen für diese Methode angibt. (Geerbt von MethodBase)
ContainsGenericParameters	Ruft einen Wert ab, der angibt, ob die generische Methode nicht zugewiesene generische Typparameter enthält. (Geerbt von MethodBase)
CustomAttributes	Ruft eine Auflistung ab, die die benutzerdefinierten Attribute dieses Elements enthält. (Geerbt von MemberInfo)
DeclaringType	Ruft einen Verweis auf das Type Objekt für den Typ ab, der dieses Element deklariert.
InitLocals	Ruft ab oder legt fest, ob die lokalen Variablen in diesem Konstruktor null initialisiert werden sollen.
IsAbstract	Ruft einen Wert ab, der angibt, ob die Methode abstrakt ist. (Geerbt von MethodBase)
IsAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder des Konstruktors beschrieben Assemblywird; d. h. die Methode oder der Konstruktor ist höchstens für andere Typen in derselben Assembly sichtbar und ist für abgeleitete Typen außerhalb der Assembly nicht sichtbar. (Geerbt von MethodBase)
IsConstructedGenericMethod	Definiert und stellt einen Konstruktor einer dynamischen Klasse dar. (Geerbt von MethodBase)
IsConstructor	Ruft einen Wert ab, der angibt, ob die Methode ein Konstruktor ist. (Geerbt von MethodBase)
IsFamily	Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode oder des Konstruktors von Family; d. h. die Methode oder der Konstruktor nur innerhalb ihrer Klasse und abgeleiteten Klassen sichtbar ist. (Geerbt von MethodBase)
IsFamilyAndAssembly	Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode oder des Konstruktors beschrieben FamANDAssemwird; d. h. die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, aber nur, wenn sie sich in derselben Assembly befinden. (Geerbt von MethodBase)
IsFamilyOrAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder des Konstruktors beschrieben FamORAssemwird; d. h. die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, wo immer sie sich befinden, und von Klassen in derselben Assembly. (Geerbt von MethodBase)
IsFinal	Ruft einen Wert ab, der angibt, ob diese Methode ist `final`. (Geerbt von MethodBase)
IsGenericMethod	Ruft einen Wert ab, der angibt, ob die Methode generisch ist. (Geerbt von MethodBase)
IsGenericMethodDefinition	Ruft einen Wert ab, der angibt, ob die Methode eine generische Methodendefinition ist. (Geerbt von MethodBase)
IsHideBySig	Ruft einen Wert ab, der angibt, ob nur ein Element derselben Art mit genau derselben Signatur in der abgeleiteten Klasse ausgeblendet ist. (Geerbt von MethodBase)
IsPrivate	Ruft einen Wert ab, der angibt, ob dieses Element privat ist. (Geerbt von MethodBase)
IsPublic	Ruft einen Wert ab, der angibt, ob es sich um eine öffentliche Methode handelt. (Geerbt von MethodBase)
IsSecurityCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor sicherheitskritisch oder sicherheitssicher auf der aktuellen Vertrauensebene ist und daher kritische Vorgänge ausführen kann. (Geerbt von MethodBase)
IsSecuritySafeCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor sicherheitssicher auf der aktuellen Vertrauensebene ist; d. h., ob sie kritische Vorgänge ausführen kann und durch transparenten Code darauf zugegriffen werden kann. (Geerbt von MethodBase)
IsSecurityTransparent	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor auf der aktuellen Vertrauensebene transparent ist und daher keine kritischen Vorgänge ausführen kann. (Geerbt von MethodBase)
IsSpecialName	Ruft einen Wert ab, der angibt, ob diese Methode einen speziellen Namen hat. (Geerbt von MethodBase)
IsStatic	Ruft einen Wert ab, der angibt, ob die Methode ist `static`. (Geerbt von MethodBase)
IsVirtual	Ruft einen Wert ab, der angibt, ob die Methode ist `virtual`. (Geerbt von MethodBase)
MemberType	Ruft einen MemberTypes Wert ab, der angibt, dass es sich bei diesem Element um einen Konstruktor handelt. (Geerbt von ConstructorInfo)
MetadataToken	Ruft einen Wert ab, der ein Metadatenelement identifiziert. (Geerbt von MemberInfo)
MethodHandle	Ruft den internen Handle für die Methode ab. Verwenden Sie dieses Handle, um auf das zugrunde liegende Metadatenhandle zuzugreifen.
MethodImplementationFlags	Ruft die MethodImplAttributes Flags ab, die die Attribute einer Methodenimplementierung angeben. (Geerbt von MethodBase)
Module	Ruft das dynamische Modul ab, in dem dieser Konstruktor definiert ist.
Name	Ruft den Namen dieses Konstruktors ab.
ReflectedType	Enthält einen Verweis auf das Type Objekt, aus dem dieses Objekt abgerufen wurde.
ReturnType	Veraltet. Ruft ab `null`.
Signature	Ruft die Signatur des Felds in Form einer Zeichenfolge ab.

Methoden

Name	Beschreibung
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Fügt diesem Konstruktor deklarative Sicherheit hinzu.
DefineParameter(Int32, ParameterAttributes, String)	Definiert einen Parameter dieses Konstruktors.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen Objekt entspricht. (Geerbt von ConstructorInfo)
GetCustomAttributes(Boolean)	Gibt alle für diesen Konstruktor definierten benutzerdefinierten Attribute zurück.
GetCustomAttributes(Type, Boolean)	Gibt die vom angegebenen Typ identifizierten benutzerdefinierten Attribute zurück.
GetCustomAttributesData()	Gibt eine Liste von CustomAttributeData Objekten zurück, die Daten zu den Attributen darstellen, die auf das Zielelement angewendet wurden. (Geerbt von MemberInfo)
GetGenericArguments()	Gibt ein Array von Type Objekten zurück, die die Typargumente einer generischen Methode oder die Typparameter einer generischen Methodendefinition darstellen. (Geerbt von MethodBase)
GetHashCode()	Gibt den Hashcode für diesen instance zurück. (Geerbt von ConstructorInfo)
GetILGenerator()	Ruft einen ILGenerator für diesen Konstruktor ab.
GetILGenerator(Int32)	Ruft ein ILGenerator Objekt mit der angegebenen MSIL-Datenstromgröße ab, das zum Erstellen eines Methodentexts für diesen Konstruktor verwendet werden kann.
GetMethodBody()	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, ruft ein MethodBody Objekt ab, das Zugriff auf den MSIL-Datenstrom, lokale Variablen und Ausnahmen für die aktuelle Methode ermöglicht. (Geerbt von MethodBase)
GetMethodImplementationFlags()	Gibt die Methodenimplementierungskennzeichnungen für diesen Konstruktor zurück.
GetModule()	Gibt einen Verweis auf das Modul zurück, das diesen Konstruktor enthält.
GetParameters()	Gibt die Parameter dieses Konstruktors zurück.
GetToken()	Gibt das MethodToken Token für diesen Konstruktor zurück.
GetType()	Ermittelt die Attribute eines Klassenkonstruktors und bietet Zugriff auf Konstruktormetadaten. (Geerbt von ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Definiert und stellt einen Konstruktor einer dynamischen Klasse dar. (Geerbt von MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Ruft den Konstruktor dynamisch auf, der von dieser Instanz für das angegebene Objekt dargestellt wird, und übergibt die angegebenen Parameter und unter den Einschränkungen des angegebenen Ordners.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Ruft den Konstruktor dynamisch auf, der von dieser Instanz mit den angegebenen Argumenten unter den Einschränkungen der angegebenen Instanz `Binder`wiedergegeben wird.
Invoke(Object, Object[])	Ruft die von der aktuellen Instanz dargestellte Methode oder den Konstruktor mithilfe der angegebenen Parameter auf. (Geerbt von MethodBase)
Invoke(Object[])	Ruft den Konstruktor auf, der von der Instanz mit den angegebenen Parametern reflektiert wird und Standardwerte für die Parameter bereitstellt, die nicht häufig verwendet werden. (Geerbt von ConstructorInfo)
IsDefined(Type, Boolean)	Überprüft, ob der angegebene benutzerdefinierte Attributtyp definiert ist.
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Legen Sie ein benutzerdefiniertes Attribut mithilfe eines angegebenen benutzerdefinierten Attribut-BLOB fest.
SetCustomAttribute(CustomAttributeBuilder)	Legen Sie ein benutzerdefiniertes Attribut mithilfe eines benutzerdefinierten Attribut-Generators fest.
SetImplementationFlags(MethodImplAttributes)	Legt die Methodenimplementierungskennzeichnungen für diesen Konstruktor fest.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Erstellt den Textkörper des Konstruktors mithilfe eines angegebenen Bytearrays Microsoft MSIL-Anweisungen (Intermediate Language).
SetSymCustomAttribute(String, Byte[])	Legt das benutzerdefinierte Attribut dieses Konstruktors fest, das symbolischen Informationen zugeordnet ist.
ToString()	Gibt diese ConstructorBuilder Instanz als ein String.

Explizite Schnittstellenimplementierungen

Name	Beschreibung
_ConstructorBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.
_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.
_ConstructorBuilder.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).
_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden.
_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von ConstructorInfo)
_ConstructorInfo.GetType()	Ruft ein Type Objekt ab, das den ConstructorInfo Typ darstellt. (Geerbt von ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können. (Geerbt von ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)	Stellt COM-Objekte mit versionsunabhängigen Zugriff auf die Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) Methode bereit. (Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])	Stellt COM-Objekte mit versionsunabhängigen Zugriff auf die Invoke(Object, Object[]) Methode bereit. (Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)	Stellt COM-Objekte mit versionsunabhängigen Zugriff auf die Invoke(BindingFlags, Binder, Object[], CultureInfo) Methode bereit. (Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])	Stellt COM-Objekte mit versionsunabhängigen Zugriff auf die Invoke(Object[]) Methode bereit. (Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MemberInfo)
_MemberInfo.GetType()	Ruft ein Type Objekt ab, das die MemberInfo Klasse darstellt. (Geerbt von MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können. (Geerbt von MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MethodBase)
_MethodBase.GetType()	Eine Beschreibung dieses Mitglieds finden Sie unter GetType(). (Geerbt von MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können. (Geerbt von MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von MethodBase)
_MethodBase.IsAbstract	Eine Beschreibung dieses Mitglieds finden Sie unter IsAbstract. (Geerbt von MethodBase)
_MethodBase.IsAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsAssembly. (Geerbt von MethodBase)
_MethodBase.IsConstructor	Eine Beschreibung dieses Mitglieds finden Sie unter IsConstructor. (Geerbt von MethodBase)
_MethodBase.IsFamily	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamily. (Geerbt von MethodBase)
_MethodBase.IsFamilyAndAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamilyAndAssembly. (Geerbt von MethodBase)
_MethodBase.IsFamilyOrAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamilyOrAssembly. (Geerbt von MethodBase)
_MethodBase.IsFinal	Eine Beschreibung dieses Mitglieds finden Sie unter IsFinal. (Geerbt von MethodBase)
_MethodBase.IsHideBySig	Eine Beschreibung dieses Mitglieds finden Sie unter IsHideBySig. (Geerbt von MethodBase)
_MethodBase.IsPrivate	Eine Beschreibung dieses Mitglieds finden Sie unter IsPrivate. (Geerbt von MethodBase)
_MethodBase.IsPublic	Eine Beschreibung dieses Mitglieds finden Sie unter IsPublic. (Geerbt von MethodBase)
_MethodBase.IsSpecialName	Eine Beschreibung dieses Mitglieds finden Sie unter IsSpecialName. (Geerbt von MethodBase)
_MethodBase.IsStatic	Eine Beschreibung dieses Mitglieds finden Sie unter IsStatic. (Geerbt von MethodBase)
_MethodBase.IsVirtual	Eine Beschreibung dieses Mitglieds finden Sie unter IsVirtual. (Geerbt von MethodBase)

Erweiterungsmethoden

Name	Beschreibung
GetCustomAttribute(MemberInfo, Type, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der auf ein angegebenes Element angewendet wird, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttribute(MemberInfo, Type)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Element angewendet wird.
GetCustomAttribute<T>(MemberInfo, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der auf ein angegebenes Element angewendet wird, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttribute<T>(MemberInfo)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Element angewendet wird.
GetCustomAttributes(MemberInfo, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes(MemberInfo, Type, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes(MemberInfo, Type)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden.
GetCustomAttributes(MemberInfo)	Ruft eine Auflistung von benutzerdefinierten Attributen ab, die auf ein angegebenes Element angewendet werden.
GetCustomAttributes<T>(MemberInfo, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes<T>(MemberInfo)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden.
IsDefined(MemberInfo, Type, Boolean)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf ein angegebenes Element angewendet werden und optional auf seine Vorgänger angewendet werden.
IsDefined(MemberInfo, Type)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf ein angegebenes Element angewendet werden.

Gilt für:

Feedback

War diese Seite hilfreich?