ConstructorBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

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 namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicPointTypeGen()
{
   Type^ pointType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew 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", int::typeid, FieldAttributes::Public );
   FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
   FieldBuilder^ zField = pointTypeBld->DefineField( "z", int::typeid, FieldAttributes::Public );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<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 bject 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 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.
   array<String^>^temp1 = {"GetX","GetY","GetZ"};
   array<String^>^mthdNames = temp1;
   System::Collections::IEnumerator^ myEnum = mthdNames->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ mthdName = safe_cast<String^>(myEnum->Current);
      MethodBuilder^ getFieldMthd = pointTypeBld->DefineMethod( mthdName, MethodAttributes::Public, int::typeid, nullptr );
      ILGenerator^ mthdIL = getFieldMthd->GetILGenerator();
      mthdIL->Emit( OpCodes::Ldarg_0 );
      if ( mthdName->Equals( "GetX" ) )
            mthdIL->Emit( OpCodes::Ldfld, xField );
      else
      if ( mthdName->Equals( "GetY" ) )
            mthdIL->Emit( OpCodes::Ldfld, yField );
      else
      if ( mthdName->Equals( "GetZ" ) )
            mthdIL->Emit( OpCodes::Ldfld, zField );



      mthdIL->Emit( OpCodes::Ret );
   }

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

int main()
{
   Type^ myDynamicType = nullptr;
   Object^ aPoint = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aPtypes = temp2;
   array<Object^>^temp3 = {4,5,6};
   array<Object^>^aPargs = temp3;
   
   // 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: " );
   System::Collections::IEnumerator^ myEnum = myDynamicType->GetMembers()->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      MemberInfo^ member = safe_cast<MemberInfo^>(myEnum->Current);
      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 );
   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, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.y = {0}", myDynamicType->InvokeMember( "GetY", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.z = {0}", myDynamicType->InvokeMember( "GetZ", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<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
}

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 jazyce MSIL (Microsoft Intermediate Language), včetně názvu, atributů, podpisu a těla konstruktoru. Používá se ve spojení s TypeBuilder třídou k vytvoření tříd za běhu. Voláním DefineConstructor získáte instanci ConstructorBuilder.

Pokud nedefinujete konstruktor pro dynamický typ, je konstruktor bez parametrů poskytován automaticky a volá konstruktor bez parametrů základní třídy.

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

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

• Pokud chcete bezparametrový konstruktor, který dělá něco víc než jen volání konstruktoru bez parametrů základní třídy, nebo který volá jiný konstruktor základní třídy nebo který dělá něco úplně jiného, musíte použít metodu TypeBuilder.DefineConstructor k vytvoření ConstructorBuildera poskytnutí vlastní implementace.

Konstruktory

ConstructorBuilder()

Inicializuje novou instanci ConstructorBuilder třídy .

Vlastnosti

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 označ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 by měly být inicializovány nula.
InitLocalsCore	Při přepsání v odvozené třídě získá nebo nastaví hodnotu, která označuje, zda místní proměnné v tomto konstruktoru by měly být inicializovány nulou.
IsAbstract	Získá hodnotu označující, zda je metoda abstraktní. (Zděděno od MethodBase)
IsAssembly	Získá hodnotu označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; Assemblyto 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 je tento MemberInfo objekt součástí sestavení uchovávaného 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 označující, zda je metoda konstruktor. (Zděděno od MethodBase)
IsFamily	Získá hodnotu označující, zda viditelnost této metody nebo konstruktoru je popsána ; Familyto 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 označující, zda viditelnost této metody nebo konstruktoru je popsána ; FamANDAssemto znamená, že metodu 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 označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; FamORAssemto znamená, že metoda nebo konstruktor mohou být volány 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 označující, zda je finaltato metoda . (Zděděno od MethodBase)
IsGenericMethod	Získá hodnotu označující, zda je metoda obecná. (Zděděno od MethodBase)
IsGenericMethodDefinition	Získá hodnotu označující, zda je metoda definice obecné metody. (Zděděno od MethodBase)
IsHideBySig	Získá hodnotu označující, zda je v odvozené třídě skrytý pouze člen stejného druhu s přesně stejným podpisem. (Zděděno od MethodBase)
IsPrivate	Získá hodnotu označující, zda je tento člen soukromý. (Zděděno od MethodBase)
IsPublic	Získá hodnotu označující, zda se jedná o veřejnou metodu. (Zděděno od MethodBase)
IsSecurityCritical	Získá hodnotu, která označ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í úroveň důvěryhodnosti; to znamená, zda může provádět kritické operace a může být přístupný transparentním kódem. (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 nelze provést kritické operace. (Zděděno od MethodBase)
IsSpecialName	Získá hodnotu označující, zda má tato metoda zvláštní název. (Zděděno od MethodBase)
IsStatic	Získá hodnotu označující, zda je staticmetoda . (Zděděno od MethodBase)
IsVirtual	Získá hodnotu označující, zda je virtualmetoda . (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	MethodImplAttributes Získá 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

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)	Vrací 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í hodnotu hash pro tuto instanci. (Zděděno od ConstructorInfo)
GetILGenerator()	Získá pro ILGenerator tento konstruktor.
GetILGenerator(Int32)	ILGenerator Získá objekt se zadanou 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á objekt 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 datovému proudu MSIL, 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.
GetType()	Zjistí atributy konstruktoru třídy a poskytuje přístup k metadatům konstruktoru. (Zděděno od ConstructorInfo)
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á spolu se zadanými parametry a pod omezeními 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ý se odráží v instanci, která má zadané parametry a poskytuje výchozí hodnoty pro parametry, které nejsou běžně používány. (Zděděno od ConstructorInfo)
IsDefined(Type, Boolean)	Zkontroluje, jestli je definovaný typ vlastního atributu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (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í vlastního tvůrce atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut v tomto konstruktoru.
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í

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