Udostępnij za pośrednictwem


ConstructorBuilder Klasa

Definicja

Definiuje i reprezentuje konstruktor klasy dynamicznej.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder abstract : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo
public abstract class ConstructorBuilder : 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
type ConstructorBuilder = class
    inherit 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
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Public MustInherit Class ConstructorBuilder
Inherits ConstructorInfo
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Poniższy przykładowy kod ilustruje kontekstowe użycie elementu 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

Uwagi

ConstructorBuilder służy do pełnego opisywania konstruktora w języku pośrednim firmy Microsoft (MSIL), w tym nazwy, atrybutów, podpisu i treści konstruktora. Jest on używany w połączeniu z klasą TypeBuilder do tworzenia klas w czasie wykonywania. Wywołaj metodę DefineConstructor , aby uzyskać wystąpienie elementu ConstructorBuilder.

Jeśli nie zdefiniujesz konstruktora dla typu dynamicznego, konstruktor bez parametrów jest dostarczany automatycznie i wywołuje konstruktor bez parametrów klasy bazowej.

Jeśli używasz metody ConstructorBuilder do definiowania konstruktora dla typu dynamicznego, konstruktor bez parametrów nie zostanie podany. Dostępne są następujące opcje udostępniania konstruktora bez parametrów oprócz zdefiniowanego konstruktora:

  • Jeśli chcesz, aby konstruktor bez parametrów, który po prostu wywołuje konstruktor bez parametrów klasy bazowej, możesz użyć TypeBuilder.DefineDefaultConstructor metody , aby utworzyć jeden (i opcjonalnie ograniczyć dostęp do niego). Nie udostępniaj implementacji dla tego konstruktora bez parametrów. Jeśli to zrobisz, podczas próby użycia konstruktora zostanie zgłoszony wyjątek. W przypadku wywołania TypeBuilder.CreateType metody nie jest zgłaszany żaden wyjątek.

  • Jeśli potrzebujesz konstruktora bez parametrów, który wykonuje coś więcej niż po prostu wywołanie konstruktora bez parametrów klasy bazowej lub który wywołuje inny konstruktor klasy bazowej lub wykonuje coś innego w całości, musisz użyć TypeBuilder.DefineConstructor metody , aby utworzyć obiekt i zapewnić własną implementację ConstructorBuilder.

Konstruktory

ConstructorBuilder()

Inicjuje nowe wystąpienie klasy ConstructorBuilder.

Właściwości

Attributes

Pobiera atrybuty tego konstruktora.

CallingConvention

CallingConventions Pobiera wartość, która zależy od tego, czy typ deklarujący jest ogólny.

CallingConvention

Pobiera wartość wskazującą konwencje wywoływania dla tej metody.

(Odziedziczone po MethodBase)
ContainsGenericParameters

Pobiera wartość wskazującą, czy metoda ogólna zawiera nieprzypisane parametry typu ogólnego.

(Odziedziczone po MethodBase)
CustomAttributes

Pobiera kolekcję zawierającą atrybuty niestandardowe tego elementu członkowskiego.

(Odziedziczone po MemberInfo)
DeclaringType

Pobiera odwołanie do Type obiektu dla typu, który deklaruje ten element członkowski.

InitLocals

Pobiera lub ustawia, czy zmienne lokalne w tym konstruktorze powinny być inicjowane zero.

InitLocalsCore

Po zastąpieniu w klasie pochodnej pobiera lub ustawia wartość, która wskazuje, czy zmienne lokalne w tym konstruktorze powinny być inicjowane zero.

IsAbstract

Pobiera wartość wskazującą, czy metoda jest abstrakcyjna.

(Odziedziczone po MethodBase)
IsAssembly

Pobiera wartość wskazującą, czy potencjalna widoczność tej metody lub konstruktora jest opisana przez Assemblymetodę , czyli metodę lub konstruktor jest widoczna co najwyżej dla innych typów w tym samym zestawie i nie jest widoczna dla typów pochodnych poza zestawem.

(Odziedziczone po MethodBase)
IsCollectible

Pobiera wartość wskazującą, czy ten MemberInfo obiekt jest częścią zestawu przechowywanego w obiekcie zbieralnym AssemblyLoadContext.

(Odziedziczone po MemberInfo)
IsConstructedGenericMethod

Definiuje i reprezentuje konstruktor klasy dynamicznej.

(Odziedziczone po MethodBase)
IsConstructor

Pobiera wartość wskazującą, czy metoda jest konstruktorem.

(Odziedziczone po MethodBase)
IsFamily

Pobiera wartość wskazującą, czy widoczność tej metody lub konstruktora jest opisana przez Familymetodę , czyli metodę lub konstruktor jest widoczna tylko w jej klasach i klasach pochodnych.

(Odziedziczone po MethodBase)
IsFamilyAndAssembly

Pobiera wartość wskazującą, czy widoczność tej metody lub konstruktora jest opisana przez FamANDAssemmetodę , czyli metodę lub konstruktor może być wywoływana przez klasy pochodne, ale tylko wtedy, gdy znajdują się w tym samym zestawie.

(Odziedziczone po MethodBase)
IsFamilyOrAssembly

Pobiera wartość wskazującą, czy potencjalna widoczność tej metody lub konstruktora jest opisana przez FamORAssemmetodę , czyli metodę lub konstruktora może być wywoływana przez klasy pochodne wszędzie tam, gdzie są, oraz według klas w tym samym zestawie.

(Odziedziczone po MethodBase)
IsFinal

Pobiera wartość wskazującą, czy ta metoda to final.

(Odziedziczone po MethodBase)
IsGenericMethod

Pobiera wartość wskazującą, czy metoda jest ogólna.

(Odziedziczone po MethodBase)
IsGenericMethodDefinition

Pobiera wartość wskazującą, czy metoda jest definicją metody ogólnej.

(Odziedziczone po MethodBase)
IsHideBySig

Pobiera wartość wskazującą, czy tylko element członkowski tego samego rodzaju z dokładnie tym samym podpisem jest ukryty w klasie pochodnej.

(Odziedziczone po MethodBase)
IsPrivate

Pobiera wartość wskazującą, czy ten element członkowski jest prywatny.

(Odziedziczone po MethodBase)
IsPublic

Pobiera wartość wskazującą, czy jest to metoda publiczna.

(Odziedziczone po MethodBase)
IsSecurityCritical

Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor ma krytyczne znaczenie dla zabezpieczeń, czy bezpieczne zabezpieczenia na bieżącym poziomie zaufania, a w związku z tym może wykonywać operacje krytyczne.

(Odziedziczone po MethodBase)
IsSecuritySafeCritical

Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor ma krytyczne znaczenie dla bezpieczeństwa na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskać do niego dostęp za pomocą przezroczystego kodu.

(Odziedziczone po MethodBase)
IsSecurityTransparent

Pobiera wartość wskazującą, czy bieżąca metoda lub konstruktor jest przezroczysta na bieżącym poziomie zaufania, a zatem nie może wykonywać operacji krytycznych.

(Odziedziczone po MethodBase)
IsSpecialName

Pobiera wartość wskazującą, czy ta metoda ma specjalną nazwę.

(Odziedziczone po MethodBase)
IsStatic

Pobiera wartość wskazującą, czy metoda to static.

(Odziedziczone po MethodBase)
IsVirtual

Pobiera wartość wskazującą, czy metoda to virtual.

(Odziedziczone po MethodBase)
MemberType

Pobiera wartość wskazującą MemberTypes , że ten element członkowski jest konstruktorem.

(Odziedziczone po ConstructorInfo)
MetadataToken

Pobiera token identyfikujący bieżący moduł dynamiczny w metadanych.

MetadataToken

Pobiera wartość identyfikującą element metadanych.

(Odziedziczone po MemberInfo)
MethodHandle

Pobiera dojście wewnętrzne dla metody . Użyj tego dojścia, aby uzyskać dostęp do dojścia do podstawowych metadanych.

MethodHandle

Pobiera uchwyt do wewnętrznej reprezentacji metadanych metody.

(Odziedziczone po MethodBase)
MethodImplementationFlags

MethodImplAttributes Pobiera flagi określające atrybuty implementacji metody.

MethodImplementationFlags

MethodImplAttributes Pobiera flagi określające atrybuty implementacji metody.

(Odziedziczone po MethodBase)
Module

Pobiera moduł dynamiczny, w którym ten konstruktor jest zdefiniowany.

Module

Pobiera moduł, w którym typ, który deklaruje element członkowski reprezentowany przez bieżący MemberInfo jest zdefiniowany.

(Odziedziczone po MemberInfo)
Name

Pobiera nazwę tego konstruktora.

ReflectedType

Przechowuje odwołanie do Type obiektu, z którego ten obiekt został uzyskany.

ReflectedType

Pobiera obiekt klasy, który został użyty do uzyskania tego wystąpienia klasy MemberInfo.

(Odziedziczone po MemberInfo)
ReturnType
Przestarzałe.

Pobiera null.

Signature

Pobiera podpis pola w postaci ciągu.

Metody

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Dodaje zabezpieczenia deklaratywne do tego konstruktora.

DefineParameter(Int32, ParameterAttributes, String)

Definiuje parametr tego konstruktora.

DefineParameterCore(Int32, ParameterAttributes, String)

Po zastąpieniu w klasie pochodnej definiuje parametr tego konstruktora.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

(Odziedziczone po ConstructorInfo)
GetCustomAttributes(Boolean)

Zwraca wszystkie atrybuty niestandardowe zdefiniowane dla tego konstruktora.

GetCustomAttributes(Boolean)

Po zastąpieniu w klasie pochodnej zwraca tablicę wszystkich atrybutów niestandardowych zastosowanych do tego elementu członkowskiego.

(Odziedziczone po MemberInfo)
GetCustomAttributes(Type, Boolean)

Zwraca atrybuty niestandardowe identyfikowane przez dany typ.

GetCustomAttributes(Type, Boolean)

Po przesłonięciu w klasie pochodnej zwraca tablicę atrybutów niestandardowych zastosowanych do tego elementu członkowskiego i zidentyfikowaną przez Typeelement .

(Odziedziczone po MemberInfo)
GetCustomAttributesData()

Zwraca listę CustomAttributeData obiektów reprezentujących dane dotyczące atrybutów, które zostały zastosowane do elementu docelowego.

(Odziedziczone po MemberInfo)
GetGenericArguments()

Zwraca tablicę Type obiektów reprezentujących argumenty typu metody ogólnej lub parametry typu definicji metody ogólnej.

(Odziedziczone po MethodBase)
GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.

(Odziedziczone po ConstructorInfo)
GetILGenerator()

Pobiera element ILGenerator dla tego konstruktora.

GetILGenerator(Int32)

ILGenerator Pobiera obiekt o określonym rozmiarze strumienia MSIL, którego można użyć do utworzenia treści metody dla tego konstruktora.

GetILGeneratorCore(Int32)

Po zastąpieniu w klasie pochodnej pobiera element ILGenerator , który może służyć do emitowania treści metody dla tego konstruktora.

GetMethodBody()

W przypadku zastąpienia w klasie pochodnej pobiera MethodBody obiekt, który zapewnia dostęp do strumienia MSIL, zmiennych lokalnych i wyjątków dla bieżącej metody.

(Odziedziczone po MethodBase)
GetMethodImplementationFlags()

Zwraca flagi implementacji metody dla tego konstruktora.

GetMethodImplementationFlags()

Po przesłonięciu w klasie pochodnej zwraca MethodImplAttributes flagi.

(Odziedziczone po MethodBase)
GetModule()

Zwraca odwołanie do modułu zawierającego ten konstruktor.

GetParameters()

Zwraca parametry tego konstruktora.

GetToken()

MethodToken Zwraca wartość reprezentującą token dla tego konstruktora.

GetType()

Odnajduje atrybuty konstruktora klasy i zapewnia dostęp do metadanych konstruktora.

(Odziedziczone po ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)

Definiuje i reprezentuje konstruktor klasy dynamicznej.

(Odziedziczone po MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

Dynamicznie wywołuje konstruktor reprezentowany przez to wystąpienie na danym obiekcie, przekazując określone parametry i pod ograniczeniami danego powiązania.

Invoke(BindingFlags, Binder, Object[], CultureInfo)

Po zaimplementowaniu w klasie pochodnej wywołuje konstruktor odzwierciedlany przez to ConstructorInfo z określonymi argumentami, zgodnie z ograniczeniami określonego Binder.

(Odziedziczone po ConstructorInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Dynamicznie wywołuje konstruktora odzwierciedlonego przez to wystąpienie z określonymi argumentami zgodnie z ograniczeniami określonego Binderelementu .

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Po zastąpieniu w klasie pochodnej wywołuje odzwierciedlonej metody lub konstruktora z podanymi parametrami.

(Odziedziczone po MethodBase)
Invoke(Object, Object[])

Wywołuje metodę lub konstruktor reprezentowany przez bieżące wystąpienie przy użyciu określonych parametrów.

(Odziedziczone po MethodBase)
Invoke(Object[])

Wywołuje konstruktora odzwierciedlonego przez wystąpienie, które ma określone parametry, podając wartości domyślne parametrów, które nie są często używane.

(Odziedziczone po ConstructorInfo)
IsDefined(Type, Boolean)

Sprawdza, czy określony typ atrybutu niestandardowego jest zdefiniowany.

IsDefined(Type, Boolean)

Po przesłonięciu w klasie pochodnej wskazuje, czy do tego elementu członkowskiego zastosowano co najmniej jeden atrybut określonego typu lub jego typów pochodnych.

(Odziedziczone po MemberInfo)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Ustaw atrybut niestandardowy przy użyciu określonego obiektu blob atrybutu niestandardowego.

SetCustomAttribute(CustomAttributeBuilder)

Ustaw atrybut niestandardowy przy użyciu konstruktora atrybutów niestandardowych.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Po zastąpieniu w klasie pochodnej ustawia atrybut niestandardowy na tym konstruktorze.

SetImplementationFlags(MethodImplAttributes)

Ustawia flagi implementacji metody dla tego konstruktora.

SetImplementationFlagsCore(MethodImplAttributes)

Po zastąpieniu w klasie pochodnej ustawia flagi implementacji metody dla tego konstruktora.

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Tworzy treść konstruktora przy użyciu określonej tablicy bajtów instrukcji języka microsoft intermediate language (MSIL).

SetSymCustomAttribute(String, Byte[])

Ustawia atrybut niestandardowy tego konstruktora skojarzony z informacjami symbolicznymi.

ToString()

Zwraca to ConstructorBuilder wystąpienie jako String.

Jawne implementacje interfejsu

_ConstructorBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.GetType()

Type Pobiera obiekt reprezentujący ConstructorInfo typ.

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Zapewnia obiektom COM dostęp niezależny od wersji do Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) metody .

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Zapewnia obiektom COM dostęp niezależny od wersji do Invoke(Object, Object[]) metody .

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Zapewnia obiektom COM dostęp niezależny od wersji do Invoke(BindingFlags, Binder, Object[], CultureInfo) metody .

(Odziedziczone po ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Zapewnia obiektom COM dostęp niezależny od wersji do Invoke(Object[]) metody .

(Odziedziczone po ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po MemberInfo)
_MemberInfo.GetType()

Type Pobiera obiekt reprezentujący klasęMemberInfo.

(Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

(Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po MethodBase)
_MethodBase.GetType()

Aby uzyskać opis tego elementu członkowskiego, zobacz GetType().

(Odziedziczone po MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

(Odziedziczone po MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po MethodBase)
_MethodBase.IsAbstract

Aby uzyskać opis tego elementu członkowskiego, zobacz IsAbstract.

(Odziedziczone po MethodBase)
_MethodBase.IsAssembly

Aby uzyskać opis tego elementu członkowskiego, zobacz IsAssembly.

(Odziedziczone po MethodBase)
_MethodBase.IsConstructor

Aby uzyskać opis tego elementu członkowskiego, zobacz IsConstructor.

(Odziedziczone po MethodBase)
_MethodBase.IsFamily

Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamily.

(Odziedziczone po MethodBase)
_MethodBase.IsFamilyAndAssembly

Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamilyAndAssembly.

(Odziedziczone po MethodBase)
_MethodBase.IsFamilyOrAssembly

Aby uzyskać opis tego elementu członkowskiego, zobacz IsFamilyOrAssembly.

(Odziedziczone po MethodBase)
_MethodBase.IsFinal

Aby uzyskać opis tego elementu członkowskiego, zobacz IsFinal.

(Odziedziczone po MethodBase)
_MethodBase.IsHideBySig

Aby uzyskać opis tego elementu członkowskiego, zobacz IsHideBySig.

(Odziedziczone po MethodBase)
_MethodBase.IsPrivate

Aby uzyskać opis tego elementu członkowskiego, zobacz IsPrivate.

(Odziedziczone po MethodBase)
_MethodBase.IsPublic

Aby uzyskać opis tego elementu członkowskiego, zobacz IsPublic.

(Odziedziczone po MethodBase)
_MethodBase.IsSpecialName

Aby uzyskać opis tego elementu członkowskiego, zobacz IsSpecialName.

(Odziedziczone po MethodBase)
_MethodBase.IsStatic

Aby uzyskać opis tego elementu członkowskiego, zobacz IsStatic.

(Odziedziczone po MethodBase)
_MethodBase.IsVirtual

Aby uzyskać opis tego elementu członkowskiego, zobacz IsVirtual.

(Odziedziczone po MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Zwraca tablicę wszystkich atrybutów niestandardowych zdefiniowanych w tym elemencie członkowskim, z wyłączeniem nazwanych atrybutów lub pustą tablicą, jeśli nie ma atrybutów niestandardowych.

(Odziedziczone po MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Zwraca tablicę atrybutów niestandardowych zdefiniowanych na tym elemencie członkowskim, identyfikowaną przez typ lub pustą tablicę, jeśli nie ma atrybutów niestandardowych tego typu.

(Odziedziczone po MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Wskazuje, czy na tym elemencie członkowskim zdefiniowano jedno lub więcej wystąpień attributeType .

(Odziedziczone po MemberInfo)

Metody rozszerzania

GetCustomAttribute(MemberInfo, Type)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.

GetCustomAttribute(MemberInfo, Type, Boolean)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttribute<T>(MemberInfo)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.

GetCustomAttribute<T>(MemberInfo, Boolean)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes(MemberInfo)

Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Boolean)

Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Type)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Type, Boolean)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes<T>(MemberInfo)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes<T>(MemberInfo, Boolean)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

IsDefined(MemberInfo, Type)

Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego.

IsDefined(MemberInfo, Type, Boolean)

Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego i, opcjonalnie, stosowane do jego elementów nadrzędnych.

GetMetadataToken(MemberInfo)

Pobiera token metadanych dla danego elementu członkowskiego, jeśli jest dostępny.

HasMetadataToken(MemberInfo)

Zwraca wartość wskazującą, czy token metadanych jest dostępny dla określonego elementu członkowskiego.

Dotyczy