ConstructorBuilder Osztály

Definíció

Névtér:

System.Reflection.Emit

Szerelvények:

netstandard.dll, System.Reflection.Emit.dll

Forrás:

ConstructorBuilder.cs

Dinamikus osztály konstruktorát definiálja és jelöli.

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

public abstract class ConstructorBuilder : System.Reflection.ConstructorInfo

type ConstructorBuilder = class
    inherit ConstructorInfo

Public MustInherit Class ConstructorBuilder
Inherits ConstructorInfo

Öröklődés

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

Példák

Az alábbi kódminta a környezetfüggő használatot szemlélteti 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

Megjegyzések

ConstructorBuilder a konstruktorok teljes leírására szolgál Microsoft köztes nyelven (MSIL), beleértve a nevet, az attribútumokat, az aláírást és a konstruktor törzsét. A rendszer az osztálysal együtt használja az TypeBuilder osztályok futásidőben történő létrehozására. Hívás DefineConstructor a példány lekéréséhez ConstructorBuilder.

Ha nem definiál konstruktort a dinamikus típushoz, a rendszer automatikusan megadja a paraméter nélküli konstruktort, és meghívja az alaposztály paraméter nélküli konstruktorát.

Ha konstruktort határoz ConstructorBuilder meg a dinamikus típushoz, a rendszer nem biztosít paraméter nélküli konstruktort. A definiált konstruktoron kívül az alábbi lehetőségek állnak rendelkezésre a paraméter nélküli konstruktor megadására:

• Ha olyan paraméter nélküli konstruktort szeretne, amely egyszerűen meghívja az alaposztály paraméter nélküli konstruktorát, a metódussal TypeBuilder.DefineDefaultConstructor létrehozhat egyet (és opcionálisan korlátozhatja a hozzáférését). Ne adjon implementációt ehhez a paraméter nélküli konstruktorhoz. Ha így tesz, a rendszer kivételt jelez a konstruktor használatakor. A metódus meghívásakor TypeBuilder.CreateType a rendszer nem ad kivételt.

• Ha olyan paraméter nélküli konstruktort szeretne, amely nem csupán az alaposztály paraméter nélküli konstruktorát hívja meg, vagy az alaposztály egy másik konstruktorát hívja meg, vagy teljesen mást csinál, akkor a TypeBuilder.DefineConstructor metódussal létre kell hoznia egy ConstructorBuilder, és saját implementációt kell biztosítania.

Konstruktorok

Name	Description
ConstructorBuilder()	Inicializálja a ConstructorBuilder osztály új példányát.

Tulajdonságok

Name	Description
Attributes	Lekéri a konstruktor attribútumait.
CallingConvention	CallingConventions Olyan értéket kap, amely attól függ, hogy a deklarálási típus általános-e.
ContainsGenericParameters	Beolvas egy értéket, amely jelzi, hogy az általános metódus nem hozzárendelt általános típusparamétereket tartalmaz-e. (Öröklődés forrása MethodBase)
CustomAttributes	Lekéri a tag egyéni attribútumait tartalmazó gyűjteményt. (Öröklődés forrása MemberInfo)
DeclaringType	Lekéri a Type tagot deklaráló típus objektumára mutató hivatkozást.
InitLocals	Lekérdezi vagy beállítja, hogy a konstruktor helyi változóinak inicializálva kell-e lenniük.
InitLocalsCore	Ha egy származtatott osztályban felül van bírálva, olyan értéket kap vagy állít be, amely jelzi, hogy a konstruktor helyi változóinak nullával kell-e inicializálva lenniük.
IsAbstract	Egy értéket kap, amely jelzi, hogy a metódus absztrakt-e. (Öröklődés forrása MethodBase)
IsAssembly	Olyan értéket kap, amely jelzi, hogy a metódus vagy a konstruktor lehetséges láthatóságát az határozza-e meg Assembly, hogy a metódus vagy a konstruktor legfeljebb ugyanazon szerelvény más típusai számára látható, és nem látható a szerelvényen kívüli származtatott típusok számára. (Öröklődés forrása MethodBase)
IsCollectible	Olyan értéket kap, amely jelzi, hogy ez az MemberInfo objektum egy vagy több gyűjteményben tárolt szerelvényre hivatkozik-e AssemblyLoadContext. (Öröklődés forrása MemberInfo)
IsConstructedGenericMethod	Dinamikus osztály konstruktorát definiálja és jelöli. (Öröklődés forrása MethodBase)
IsConstructor	Egy értéket kap, amely jelzi, hogy a metódus konstruktor-e. (Öröklődés forrása MethodBase)
IsFamily	Egy értéket kap, amely jelzi, hogy a metódus vagy a konstruktor láthatóságát a rendszer leírja-e Family; vagyis a metódus vagy a konstruktor csak az osztályán belül és a származtatott osztályokban látható. (Öröklődés forrása MethodBase)
IsFamilyAndAssembly	Olyan értéket kap, amely jelzi, hogy a metódus vagy a konstruktor láthatóságát a rendszer leírja-e FamANDAssem; vagyis a metódust vagy a konstruktort származtatott osztályok hívhatják meg, de csak akkor, ha ugyanabban a szerelvényben vannak. (Öröklődés forrása MethodBase)
IsFamilyOrAssembly	Egy értéket kap, amely jelzi, hogy a metódus vagy konstruktor lehetséges láthatóságát a rendszer leírja-e FamORAssem; vagyis a metódust vagy konstruktort származtatott osztályok hívhatják meg, bárhol is vannak, és az ugyanabban a szerelvényben lévő osztályok szerint. (Öröklődés forrása MethodBase)
IsFinal	Egy értéket kap, amely jelzi, hogy ez a metódus .final (Öröklődés forrása MethodBase)
IsGenericMethod	Egy értéket kap, amely jelzi, hogy a metódus általános-e. (Öröklődés forrása MethodBase)
IsGenericMethodDefinition	Beolvas egy értéket, amely jelzi, hogy a metódus általános metódusdefiníció-e. (Öröklődés forrása MethodBase)
IsHideBySig	Egy értéket kap, amely azt jelzi, hogy csak egy azonos típusú, pontosan azonos aláírással rendelkező tag van-e elrejtve a származtatott osztályban. (Öröklődés forrása MethodBase)
IsPrivate	Beolvas egy értéket, amely jelzi, hogy ez a tag privát-e. (Öröklődés forrása MethodBase)
IsPublic	Beolvas egy értéket, amely jelzi, hogy ez nyilvános metódus-e. (Öröklődés forrása MethodBase)
IsSecurityCritical	Olyan értéket kap, amely jelzi, hogy az aktuális metódus vagy konstruktor biztonsági szempontból kritikus vagy biztonsági szempontból biztonságos-kritikus a jelenlegi megbízhatósági szinten, ezért kritikus műveleteket hajthat végre. (Öröklődés forrása MethodBase)
IsSecuritySafeCritical	Olyan értéket kap, amely jelzi, hogy az aktuális metódus vagy konstruktor biztonsági szempontból biztonságos-e az aktuális megbízhatósági szinten; vagyis hogy képes-e kritikus műveleteket végrehajtani, és transzparens kóddal elérhető-e. (Öröklődés forrása MethodBase)
IsSecurityTransparent	Olyan értéket kap, amely jelzi, hogy az aktuális metódus vagy konstruktor transzparens-e az aktuális megbízhatósági szinten, ezért nem hajthat végre kritikus műveleteket. (Öröklődés forrása MethodBase)
IsSpecialName	Egy értéket kap, amely jelzi, hogy a metódusnak van-e különleges neve. (Öröklődés forrása MethodBase)
IsStatic	Egy értéket kap, amely jelzi, hogy a metódus .static (Öröklődés forrása MethodBase)
IsVirtual	Egy értéket kap, amely jelzi, hogy a metódus .virtual (Öröklődés forrása MethodBase)
MemberType	MemberTypes Olyan értéket kap, amely jelzi, hogy ez a tag konstruktor. (Öröklődés forrása ConstructorInfo)
MetadataToken	Lekéri a metaadatokban az aktuális dinamikus modult azonosító jogkivonatot.
MethodHandle	Lekéri a metódus belső fogópontját. Ezzel a leíróval érheti el a mögöttes metaadat-leírót.
MethodImplementationFlags	Lekéri a MethodImplAttributes metódus-implementáció attribútumait meghatározó jelzőket. (Öröklődés forrása MethodBase)
Module	Lekéri azt a dinamikus modult, amelyben ez a konstruktor definiálva van.
Name	Lekéri a konstruktor nevét.
ReflectedType	Arra az Type objektumra mutató hivatkozást tartalmaz, amelyből ezt az objektumot beszerezték.

Metódusok

Name	Description
DefineParameter(Int32, ParameterAttributes, String)	A konstruktor paraméterét határozza meg.
DefineParameterCore(Int32, ParameterAttributes, String)	Ha egy származtatott osztályban felül van bírálva, a konstruktor paraméterét határozza meg.
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal. (Öröklődés forrása ConstructorInfo)
GetCustomAttributes(Boolean)	A konstruktorhoz definiált összes egyéni attribútumot adja vissza.
GetCustomAttributes(Type, Boolean)	Az adott típus által azonosított egyéni attribútumokat adja vissza.
GetCustomAttributesData()	Visszaadja a CustomAttributeData céltagra alkalmazott attribútumok adatait képviselő objektumok listáját. (Öröklődés forrása MemberInfo)
GetHashCode()	A példány kivonatkódját adja vissza. (Öröklődés forrása ConstructorInfo)
GetILGenerator()	Kap egy ILGenerator ilyen konstruktort.
GetILGenerator(Int32)	ILGenerator Lekéri a megadott MSIL-streammérettel rendelkező objektumot, amely a konstruktorhoz használható metódustörzs létrehozásához használható.
GetILGeneratorCore(Int32)	Ha felül van bírálva egy származtatott osztályban, a ILGenerator konstruktor metódustörzsének kibocsátására használható lesz.
GetMethodBody()	Ha egy származtatott osztályban felül van bírálva, egy MethodBody objektumot kap, amely hozzáférést biztosít az MSIL-adatfolyamhoz, a helyi változókhoz és az aktuális metódus kivételeihez. (Öröklődés forrása MethodBase)
GetMethodImplementationFlags()	A konstruktor metódus-implementálási jelzőit adja vissza.
GetParameters()	A konstruktor paramétereit adja vissza.
HasSameMetadataDefinitionAs(MemberInfo)	Dinamikus osztály konstruktorát definiálja és jelöli. (Öröklődés forrása MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Dinamikusan meghívja a példány által képviselt konstruktort az adott objektumon, a megadott paraméterek mentén haladva, az adott kötés kényszerei szerint.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Dinamikusan meghívja a példány által tükrözött konstruktort a megadott argumentumokkal, a megadott Binderkorlátozásokkal.
Invoke(Object, Object[])	Meghívja az aktuális példány által képviselt metódust vagy konstruktort a megadott paraméterekkel. (Öröklődés forrása MethodBase)
Invoke(Object[])	Meghívja a konstruktort, amely a megadott paraméterekkel rendelkezik, és alapértelmezett értékeket ad meg a gyakran nem használt paraméterekhez. (Öröklődés forrása ConstructorInfo)
IsDefined(Type, Boolean)	Ellenőrzi, hogy a megadott egyéni attribútumtípus definiálva van-e.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Egyéni attribútum beállítása egy megadott egyéni attribútumblob használatával.
SetCustomAttribute(CustomAttributeBuilder)	Egyéni attribútum beállítása egyéni attribútumszerkesztővel.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Ha egy származtatott osztályban felül van bírálva, beállít egy egyéni attribútumot ezen a konstruktoron.
SetImplementationFlags(MethodImplAttributes)	Beállítja a konstruktor metódus-implementálási jelzőit.
SetImplementationFlagsCore(MethodImplAttributes)	Ha egy származtatott osztályban felül van bírálva, beállítja a konstruktor metódus-implementálási jelzőit.
ToString()	Ezt a ConstructorBuilder példányt Stringadja vissza .

Bővítő metódusok

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Lekéri a megadott típusú egyéni attribútumot, amely egy adott tagra lesz alkalmazva, és opcionálisan az adott tag elődeit vizsgálja meg.
GetCustomAttribute(MemberInfo, Type)	Egy megadott típusú egyéni attribútumot kér le, amelyet egy adott tagra alkalmaz.
GetCustomAttribute<T>(MemberInfo, Boolean)	Lekéri a megadott típusú egyéni attribútumot, amely egy adott tagra lesz alkalmazva, és opcionálisan az adott tag elődeit vizsgálja meg.
GetCustomAttribute<T>(MemberInfo)	Egy megadott típusú egyéni attribútumot kér le, amelyet egy adott tagra alkalmaz.
GetCustomAttributes(MemberInfo, Boolean)	Lekéri a megadott tagra alkalmazott egyéni attribútumok gyűjteményét, és opcionálisan az adott tag őseit vizsgálja meg.
GetCustomAttributes(MemberInfo, Type, Boolean)	Lekéri a megadott típusú egyéni attribútumok gyűjteményét, amelyek egy adott tagra vonatkoznak, és opcionálisan az adott tag elődeit is érintik.
GetCustomAttributes(MemberInfo, Type)	Egy megadott típusú egyéni attribútumok gyűjteményét kéri le, amelyeket egy adott tagra alkalmaz.
GetCustomAttributes(MemberInfo)	Egy adott tagra alkalmazott egyéni attribútumok gyűjteményét kéri le.
GetCustomAttributes<T>(MemberInfo, Boolean)	Lekéri a megadott típusú egyéni attribútumok gyűjteményét, amelyek egy adott tagra vonatkoznak, és opcionálisan az adott tag elődeit is érintik.
GetCustomAttributes<T>(MemberInfo)	Egy megadott típusú egyéni attribútumok gyűjteményét kéri le, amelyeket egy adott tagra alkalmaz.
GetMetadataToken(MemberInfo)	Ha elérhető, lekéri az adott tag metaadat-jogkivonatát.
HasMetadataToken(MemberInfo)	Olyan értéket ad vissza, amely jelzi, hogy elérhető-e metaadat-jogkivonat a megadott tag számára.
IsDefined(MemberInfo, Type, Boolean)	Azt jelzi, hogy a megadott típusú egyéni attribútumok alkalmazhatók-e egy adott tagra, és szükség esetén alkalmazva vannak-e az elődökre.
IsDefined(MemberInfo, Type)	Azt jelzi, hogy a megadott típusú egyéni attribútumok alkalmazhatók-e egy adott tagra.