ConstructorBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.dll

Zdroj:

ConstructorBuilder.cs

Definuje a představuje konstruktor dynamické třídy.

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

Dědičnost

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

Příklady

Následující ukázka kódu znázorňuje kontextové použití objektu 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

Poznámky

ConstructorBuilder slouží k úplnému popisu konstruktoru v Microsoft zprostředkující jazyk (MSIL), včetně názvu, atributů, podpisu a textu konstruktoru. Používá se ve spojení s TypeBuilder třídou k vytváření tříd za běhu. Volání DefineConstructor pro získání instance ConstructorBuilder.

Pokud nedefinujete konstruktor pro váš dynamický typ, poskytuje se konstruktor bez parametrů automaticky a volá konstruktor bez parametrů základní třídy.

Pokud používáte ConstructorBuilder k definování konstruktoru pro váš dynamický typ, není zadán konstruktor bez parametrů. Kromě konstruktoru, který jste definovali, máte následující možnosti pro poskytování konstruktoru bez parametrů:

• Pokud chcete konstruktor bez parametrů, který jednoduše volá konstruktor bez parametrů základní třídy, můžete použít metodu TypeBuilder.DefineDefaultConstructor k vytvoření (a volitelně omezit přístup k ní). Neposkytujte implementaci tohoto konstruktoru bez parametrů. Pokud ano, při pokusu o použití konstruktoru se vyvolá výjimka. Při TypeBuilder.CreateType zavolání metody není vyvolána žádná výjimka.

• Chcete-li konstruktor bez parametrů, který dělá něco víc než jednoduše volání konstruktoru bez parametrů základní třídy, nebo který volá jiný konstruktor základní třídy, nebo který dělá něco jiného zcela, musíte použít TypeBuilder.DefineConstructor metodu ConstructorBuilderk vytvoření a poskytnout vlastní implementaci.

Konstruktory

Name	Description
ConstructorBuilder()	Inicializuje novou instanci ConstructorBuilder třídy.

Vlastnosti

Name	Description
Attributes	Získá atributy pro tento konstruktor.
CallingConvention	CallingConventions Získá hodnotu, která závisí na tom, zda deklarující typ je obecný.
ContainsGenericParameters	Získá hodnotu určující, zda obecná metoda obsahuje nepřiřazené parametry obecného typu. (Zděděno od MethodBase)
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaringType	Získá odkaz na Type objekt pro typ, který deklaruje tento člen.
InitLocals	Získá nebo nastaví, zda místní proměnné v tomto konstruktoru mají být inicializovány nula.
InitLocalsCore	Při přepsání v odvozené třídě získá nebo nastaví hodnotu, která určuje, zda místní proměnné v tomto konstruktoru mají být inicializovány nula.
IsAbstract	Získá hodnotu určující, zda metoda je abstraktní. (Zděděno od MethodBase)
IsAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána Assembly; to znamená, že metoda nebo konstruktor je viditelná nejvýše pro jiné typy ve stejném sestavení a není viditelná pro odvozené typy mimo sestavení. (Zděděno od MethodBase)
IsCollectible	Získá hodnotu, která označuje, zda tento MemberInfo objekt odkazuje na jedno nebo více sestavení uložených v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsConstructedGenericMethod	Definuje a představuje konstruktor dynamické třídy. (Zděděno od MethodBase)
IsConstructor	Získá hodnotu určující, zda metoda je konstruktor. (Zděděno od MethodBase)
IsFamily	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána Family; to znamená, že metoda nebo konstruktor je viditelná pouze v rámci své třídy a odvozené třídy. (Zděděno od MethodBase)
IsFamilyAndAssembly	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána FamANDAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami, ale pouze pokud jsou ve stejném sestavení. (Zděděno od MethodBase)
IsFamilyOrAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána FamORAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami bez ohledu na to, kde jsou, a třídami ve stejném sestavení. (Zděděno od MethodBase)
IsFinal	Získá hodnotu určující, zda tato metoda je final. (Zděděno od MethodBase)
IsGenericMethod	Získá hodnotu určující, zda je metoda obecná. (Zděděno od MethodBase)
IsGenericMethodDefinition	Získá hodnotu určující, zda metoda je obecná definice metody. (Zděděno od MethodBase)
IsHideBySig	Získá hodnotu určující, zda je v odvozené třídě skrytý pouze člen stejného typu s přesně stejným podpisem. (Zděděno od MethodBase)
IsPrivate	Získá hodnotu určující, zda je tento člen soukromý. (Zděděno od MethodBase)
IsPublic	Získá hodnotu určující, zda je to veřejná metoda. (Zděděno od MethodBase)
IsSecurityCritical	Získá hodnotu, která určuje, zda aktuální metoda nebo konstruktor je kritická zabezpečení nebo zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti, a proto může provádět kritické operace. (Zděděno od MethodBase)
IsSecuritySafeCritical	Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti; to znamená, jestli může provádět kritické operace a může k němu přistupovat transparentní kód. (Zděděno od MethodBase)
IsSecurityTransparent	Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je transparentní na aktuální úrovni důvěryhodnosti, a proto nemůže provádět kritické operace. (Zděděno od MethodBase)
IsSpecialName	Získá hodnotu označující, zda tato metoda má speciální název. (Zděděno od MethodBase)
IsStatic	Získá hodnotu určující, zda metoda je static. (Zděděno od MethodBase)
IsVirtual	Získá hodnotu určující, zda metoda je virtual. (Zděděno od MethodBase)
MemberType	MemberTypes Získá hodnotu označující, že tento člen je konstruktor. (Zděděno od ConstructorInfo)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
MethodHandle	Získá interní popisovač pro metodu. Tento popisovač použijte pro přístup k podkladovému popisovači metadat.
MethodImplementationFlags	Získá MethodImplAttributes příznaky, které určují atributy implementace metody. (Zděděno od MethodBase)
Module	Získá dynamický modul, ve kterém je tento konstruktor definován.
Name	Načte název tohoto konstruktoru.
ReflectedType	Obsahuje odkaz na Type objekt, ze kterého byl tento objekt získán.

Metody

Name	Description
DefineParameter(Int32, ParameterAttributes, String)	Definuje parametr tohoto konstruktoru.
DefineParameterCore(Int32, ParameterAttributes, String)	Při přepsání v odvozené třídě definuje parametr tohoto konstruktoru.
Equals(Object)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému objektu. (Zděděno od ConstructorInfo)
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy definované pro tento konstruktor.
GetCustomAttributes(Type, Boolean)	Vrátí vlastní atributy identifikované daným typem.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena. (Zděděno od MemberInfo)
GetGenericArguments()	Vrátí pole Type objektů, které představují argumenty typu obecné metody nebo parametry typu definice obecné metody. (Zděděno od MethodBase)
GetHashCode()	Vrátí kód hash pro tuto instanci. (Zděděno od ConstructorInfo)
GetILGenerator()	ILGenerator Získá pro tento konstruktor.
GetILGenerator(Int32)	Získá objekt se zadanou ILGenerator velikost datového proudu MSIL, který lze použít k sestavení těla metody pro tento konstruktor.
GetILGeneratorCore(Int32)	Při přepsání v odvozené třídě získá ILGenerator , který lze použít k vygenerování těla metody pro tento konstruktor.
GetMethodBody()	Při přepsání v odvozené třídě získá MethodBody objekt, který poskytuje přístup k msIL stream, místní proměnné a výjimky pro aktuální metodu. (Zděděno od MethodBase)
GetMethodImplementationFlags()	Vrátí příznaky implementace metody pro tento konstruktor.
GetParameters()	Vrátí parametry tohoto konstruktoru.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a představuje konstruktor dynamické třídy. (Zděděno od MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Dynamicky vyvolá konstruktor reprezentovaný touto instancí na daném objektu, předávání zadaných parametrů a v rámci omezení daného pořadače.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Dynamicky vyvolá konstruktor reflektovaný touto instancí se zadanými argumenty v rámci omezení zadaného Binder.
Invoke(Object, Object[])	Vyvolá metodu nebo konstruktor reprezentovaný aktuální instancí pomocí zadaných parametrů. (Zděděno od MethodBase)
Invoke(Object[])	Vyvolá konstruktor, který odráží instanci se zadanými parametry a poskytuje výchozí hodnoty parametrů, které se běžně nepoužívají. (Zděděno od ConstructorInfo)
IsDefined(Type, Boolean)	Zkontroluje, jestli je definovaný zadaný typ vlastního atributu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Nastavte vlastní atribut pomocí zadaného objektu blob vlastního atributu.
SetCustomAttribute(CustomAttributeBuilder)	Nastavte vlastní atribut pomocí tvůrce vlastních atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut pro tento konstruktor.
SetImplementationFlags(MethodImplAttributes)	Nastaví příznaky implementace metody pro tento konstruktor.
SetImplementationFlagsCore(MethodImplAttributes)	Při přepsání v odvozené třídě nastaví příznaky implementace metody pro tento konstruktor.
ToString()	Vrátí tuto ConstructorBuilder instanci jako String.

Metody rozšíření

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které se použijí na zadaného člena, a volitelně zkontroluje předky daného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které se použijí na zadaný člen.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetMetadataToken(MemberInfo)	Získá token metadat pro daného člena, pokud je k dispozici.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která určuje, zda je token metadat k dispozici pro zadaného člena.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaný člen a volitelně se použijí na jeho nadřazené objekty.
IsDefined(MemberInfo, Type)	Určuje, zda jsou u zadaného člena použity vlastní atributy zadaného typu.