ConstructorBuilder Classe

Definizione

Definisce e rappresenta un costruttore di una classe dinamica.Defines and represents a constructor of a dynamic class.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder
[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
    interface _ConstructorBuilder
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
Ereditarietà
Attributi
Implementazioni

Esempi

Nell'esempio di codice riportato di seguito viene illustrato l'utilizzo contestuale di una ConstructorBuilder.The following code sample illustrates the contextual usage of a 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

Commenti

ConstructorBuilder viene utilizzato per descrivere completamente un costruttore in Microsoft Intermediate Language (MSIL), inclusi il nome, gli attributi, la firma e il corpo del costruttore.ConstructorBuilder is used to fully describe a constructor in Microsoft intermediate language (MSIL), including the name, attributes, signature, and constructor body. Viene usato insieme alla classe TypeBuilder per creare classi in fase di esecuzione.It is used in conjunction with the TypeBuilder class to create classes at run time. Chiamare DefineConstructor per ottenere un'istanza di ConstructorBuilder.Call DefineConstructor to get an instance of ConstructorBuilder.

Se non si definisce un costruttore per il tipo dinamico, viene fornito automaticamente un costruttore senza parametri e viene chiamato il costruttore senza parametri della classe di base.If you do not define a constructor for your dynamic type, a parameterless constructor is provided automatically, and it calls the parameterless constructor of the base class.

Se si usa ConstructorBuilder per definire un costruttore per il tipo dinamico, non viene fornito un costruttore senza parametri.If you use ConstructorBuilder to define a constructor for your dynamic type, a parameterless constructor is not provided. Sono disponibili le opzioni seguenti per fornire un costruttore senza parametri oltre al costruttore definito:You have the following options for providing a parameterless constructor in addition to the constructor you defined:

  • Se si vuole un costruttore senza parametri che chiama semplicemente il costruttore senza parametri della classe base, è possibile usare il metodo TypeBuilder.DefineDefaultConstructor per crearne uno (e, facoltativamente, limitarne l'accesso).If you want a parameterless constructor that simply calls the parameterless constructor of the base class, you can use the TypeBuilder.DefineDefaultConstructor method to create one (and optionally restrict access to it). Non fornire un'implementazione per questo costruttore senza parametri.Do not provide an implementation for this parameterless constructor. In tal caso, viene generata un'eccezione quando si tenta di utilizzare il costruttore.If you do, an exception is thrown when you try to use the constructor. Quando viene chiamato il metodo TypeBuilder.CreateType, non viene generata alcuna eccezione.No exception is thrown when the TypeBuilder.CreateType method is called.

  • Se si desidera un costruttore senza parametri che esegue un'operazione più che semplicemente chiamando il costruttore senza parametri della classe base o che chiama un altro costruttore della classe base o che esegue un'altra operazione completamente, è necessario utilizzare il metodo TypeBuilder.DefineConstructor per creare un ConstructorBuildere fornire un'implementazione personalizzata.If you want a parameterless constructor that does something more than simply calling the parameterless constructor of the base class, or that calls another constructor of the base class, or that does something else entirely, you must use the TypeBuilder.DefineConstructor method to create a ConstructorBuilder, and provide your own implementation.

Proprietà

Attributes

Ottiene gli attributi per questo costruttore.Gets the attributes for this constructor.

CallingConvention

Ottiene un valore CallingConventions che dipende dal fatto che il tipo dichiarante sia generico o non generico.Gets a CallingConventions value that depends on whether the declaring type is generic.

ContainsGenericParameters

Ottiene un valore che indica se il metodo generico contiene parametri di tipo generico non assegnati.Gets a value indicating whether the generic method contains unassigned generic type parameters.

(Ereditato da MethodBase)
CustomAttributes

Ottiene una raccolta che contiene gli attributi personalizzati del membro.Gets a collection that contains this member's custom attributes.

(Ereditato da MemberInfo)
DeclaringType

Ottiene un riferimento all'oggetto Type per il tipo che dichiara questo membro.Gets a reference to the Type object for the type that declares this member.

InitLocals

Ottiene o imposta un valore che indica se le variabili locali nel costruttore devono essere inizializzate su zero.Gets or sets whether the local variables in this constructor should be zero-initialized.

IsAbstract

Ottiene un valore che indica se il metodo è astratto.Gets a value indicating whether the method is abstract.

(Ereditato da MethodBase)
IsAssembly

Ottiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da Assembly, ovvero se il metodo o costruttore è visibile al massimo ad altri tipi dello stesso assembly, ma non ai tipi derivati all'esterno dell'assembly.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Ereditato da MethodBase)
IsCollectible

Ottiene un valore che indica se questo oggetto MemberInfo fa parte di un assembly conservato in un AssemblyLoadContext ritirabile.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Ereditato da MemberInfo)
IsConstructedGenericMethod (Ereditato da MethodBase)
IsConstructor

Ottiene un valore che indica se il metodo è un costruttore.Gets a value indicating whether the method is a constructor.

(Ereditato da MethodBase)
IsFamily

Ottiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da Family, ovvero se il metodo o costruttore è visibile solo all'interno della relativa classe e delle classi derivate.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Ereditato da MethodBase)
IsFamilyAndAssembly

Ottiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da FamANDAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate, ma solo se appartenenti allo stesso assembly.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(Ereditato da MethodBase)
IsFamilyOrAssembly

Ottiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da FamORAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate indipendentemente dalla posizione e da classi appartenenti allo stesso assembly.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Ereditato da MethodBase)
IsFinal

Ottiene un valore che indica se il metodo è final.Gets a value indicating whether this method is final.

(Ereditato da MethodBase)
IsGenericMethod

Ottiene un valore che indica se il metodo è generico.Gets a value indicating whether the method is generic.

(Ereditato da MethodBase)
IsGenericMethodDefinition

Ottiene un valore che indica se il metodo è una definizione di un metodo generico.Gets a value indicating whether the method is a generic method definition.

(Ereditato da MethodBase)
IsHideBySig

Ottiene un valore che indica se nella classe derivata è nascosto un solo membro dello stesso tipo che riporta esattamente la stessa firma.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Ereditato da MethodBase)
IsPrivate

Ottiene un valore che indica se questo membro è privato.Gets a value indicating whether this member is private.

(Ereditato da MethodBase)
IsPublic

Ottiene un valore che indica se si tratta di un metodo pubblico.Gets a value indicating whether this is a public method.

(Ereditato da MethodBase)
IsSecurityCritical

Ottiene un valore che indica se il metodo o il costruttore corrente è critico per la sicurezza o security-safe-critical al livello di attendibilità corrente, e pertanto può eseguire operazioni critiche.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(Ereditato da MethodBase)
IsSecuritySafeCritical

Ottiene un valore che indica se il metodo o il costruttore corrente è security-safe-critical al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche ed essere richiamato da codice trasparente.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(Ereditato da MethodBase)
IsSecurityTransparent

Ottiene un valore che indica se il metodo o il costruttore corrente è trasparente al livello di attendibilità corrente, e pertanto non può eseguire operazioni critiche.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(Ereditato da MethodBase)
IsSpecialName

Ottiene un valore che indica se questo metodo ha un nome speciale.Gets a value indicating whether this method has a special name.

(Ereditato da MethodBase)
IsStatic

Ottiene un valore che indica se il metodo è static.Gets a value indicating whether the method is static.

(Ereditato da MethodBase)
IsVirtual

Ottiene un valore che indica se il metodo è virtual.Gets a value indicating whether the method is virtual.

(Ereditato da MethodBase)
MemberType

Ottiene un valore di MemberTypes che indica che questo membro è un costruttore.Gets a MemberTypes value indicating that this member is a constructor.

(Ereditato da ConstructorInfo)
MetadataToken

Ottiene un valore che identifica un elemento di metadati.Gets a value that identifies a metadata element.

(Ereditato da MemberInfo)
MethodHandle

Ottiene l'handle interno per il metodo.Gets the internal handle for the method. Questo handle consente di accedere all'handle dei metadati sottostanti.Use this handle to access the underlying metadata handle.

MethodImplementationFlags

Ottiene i flag MethodImplAttributes che specificano gli attributi di implementazione di un metodo.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

Module

Ottiene il modulo dinamico in cui è definito il costruttore.Gets the dynamic module in which this constructor is defined.

Name

Recupera il nome del costruttore.Retrieves the name of this constructor.

ReflectedType

Contiene un riferimento all'oggetto Type da cui è stato ottenuto questo oggetto.Holds a reference to the Type object from which this object was obtained.

ReturnType

Ottiene l'oggetto null.Gets null.

Signature

Recupera la firma del campo sotto forma di stringa.Retrieves the signature of the field in the form of a string.

Metodi

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Aggiunge sicurezza dichiarativa a questo costruttore.Adds declarative security to this constructor.

DefineParameter(Int32, ParameterAttributes, String)

Definisce un parametro del costruttore.Defines a parameter of this constructor.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value that indicates whether this instance is equal to a specified object.

(Ereditato da ConstructorInfo)
GetCustomAttributes(Boolean)

Restituisce tutti gli attributi personalizzati definiti per questo costruttore.Returns all the custom attributes defined for this constructor.

GetCustomAttributes(Type, Boolean)

Restituisce gli attributi personalizzati identificati dal tipo specificato.Returns the custom attributes identified by the given type.

GetCustomAttributesData()

Restituisce un elenco di oggetti CustomAttributeData che rappresentano i dati relativi agli attributi applicati al membro di destinazione.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Ereditato da MemberInfo)
GetGenericArguments()

Restituisce una matrice di oggetti Type che rappresentano gli argomenti di tipo di un metodo generico o i parametri di tipo della definizione di un metodo generico.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Ereditato da MethodBase)
GetHashCode()

Restituisce il codice hash relativo a questa istanza.Returns the hash code for this instance.

(Ereditato da ConstructorInfo)
GetILGenerator()

Ottiene un oggetto ILGenerator per il costruttore.Gets an ILGenerator for this constructor.

GetILGenerator(Int32)

Ottiene un oggetto ILGenerator, con le dimensioni di flusso MSIL specificate, che può essere usato per compilare il corpo di un metodo per il costruttore.Gets an ILGenerator object, with the specified MSIL stream size, that can be used to build a method body for this constructor.

GetMethodBody()

Se viene eseguito l'override in una classe derivata, ottiene un oggetto MethodBody che consente di accedere al flusso MSIL, alle variabili locali e alle eccezioni per il metodo corrente.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(Ereditato da MethodBase)
GetMethodImplementationFlags()

Restituisce i flag di implementazione dei metodi per il costruttore.Returns the method implementation flags for this constructor.

GetModule()

Restituisce un riferimento al modulo che contiene il costruttore.Returns a reference to the module that contains this constructor.

GetParameters()

Restituisce il parametro del costruttore.Returns the parameters of this constructor.

GetToken()

Restituisce l'oggetto MethodToken che rappresenta il token per questo costruttore.Returns the MethodToken that represents the token for this constructor.

GetType() (Ereditato da ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Ereditato da MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

Richiama in modo dinamico il costruttore rappresentato da questa istanza sull'oggetto indicato, passando i parametri specificati e con i vincoli del binder indicato.Dynamically invokes the constructor represented by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder.

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

Richiama in modo dinamico il costruttore ottenuto tramite reflection da questa istanza con gli argomenti specificati, in base ai vincoli dell'oggetto Binder specificato.Dynamically invokes the constructor reflected by this instance with the specified arguments, under the constraints of the specified Binder.

Invoke(Object, Object[])

Richiama il metodo o il costruttore rappresentato dall'istanza corrente usando i parametri specificati.Invokes the method or constructor represented by the current instance, using the specified parameters.

(Ereditato da MethodBase)
Invoke(Object[])

Richiama il costruttore riflesso dall'istanza che ha i parametri specificati fornendo i valori predefiniti per i parametri che non sono di uso comune.Invokes the constructor reflected by the instance that has the specified parameters, providing default values for the parameters not commonly used.

(Ereditato da ConstructorInfo)
IsDefined(Type, Boolean)

Controlla se il tipo di attributo personalizzato specificato è definito.Checks if the specified custom attribute type is defined.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Imposta un attributo personalizzato usando un BLOB di attributi personalizzati specificato.Set a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

Impostare un attributo personalizzato usando un generatore di attributi personalizzati.Set a custom attribute using a custom attribute builder.

SetImplementationFlags(MethodImplAttributes)

Imposta l'implementazione dei metodi per il costruttore.Sets the method implementation flags for this constructor.

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

Crea il corpo del costruttore usando una matrice di byte specificata di istruzioni Microsoft Intermediate Language (MSIL).Creates the body of the constructor by using a specified byte array of Microsoft intermediate language (MSIL) instructions.

SetSymCustomAttribute(String, Byte[])

Imposta l'attributo personalizzato del costruttore associato alle informazioni simboliche.Sets this constructor's custom attribute associated with symbolic information.

ToString()

Restituisce questa istanza di ConstructorBuilder come oggetto String.Returns this ConstructorBuilder instance as a String.

Implementazioni dell'interfaccia esplicita

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

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

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da ConstructorInfo)
_ConstructorInfo.GetType()

Ottiene un oggetto Type che rappresenta il tipo ConstructorInfo.Gets a Type object representing the ConstructorInfo type.

(Ereditato da ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Ereditato da ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Fornisce oggetti COM con accesso indipendente dalla versione al metodo Invoke(Object, BindingFlags, Binder, Object[], CultureInfo).Provides COM objects with version-independent access to the Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) method.

(Ereditato da ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Fornisce oggetti COM con accesso indipendente dalla versione al metodo Invoke(Object, Object[]).Provides COM objects with version-independent access to the Invoke(Object, Object[]) method.

(Ereditato da ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Fornisce oggetti COM con accesso indipendente dalla versione al metodo Invoke(BindingFlags, Binder, Object[], CultureInfo).Provides COM objects with version-independent access to the Invoke(BindingFlags, Binder, Object[], CultureInfo) method.

(Ereditato da ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Fornisce oggetti COM con accesso indipendente dalla versione al metodo Invoke(Object[]).Provides COM objects with version-independent access to the Invoke(Object[]) method.

(Ereditato da ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da MemberInfo)
_MemberInfo.GetType()

Ottiene un oggetto Type che rappresenta la classe MemberInfo.Gets a Type object representing the MemberInfo class.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da MethodBase)
_MethodBase.GetType()

Per una descrizione di questo membro, vedere GetType().For a description of this member, see GetType().

(Ereditato da MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Ereditato da MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da MethodBase)
_MethodBase.IsAbstract

Per una descrizione di questo membro, vedere IsAbstract.For a description of this member, see IsAbstract.

(Ereditato da MethodBase)
_MethodBase.IsAssembly

Per una descrizione di questo membro, vedere IsAssembly.For a description of this member, see IsAssembly.

(Ereditato da MethodBase)
_MethodBase.IsConstructor

Per una descrizione di questo membro, vedere IsConstructor.For a description of this member, see IsConstructor.

(Ereditato da MethodBase)
_MethodBase.IsFamily

Per una descrizione di questo membro, vedere IsFamily.For a description of this member, see IsFamily.

(Ereditato da MethodBase)
_MethodBase.IsFamilyAndAssembly

Per una descrizione di questo membro, vedere IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Ereditato da MethodBase)
_MethodBase.IsFamilyOrAssembly

Per una descrizione di questo membro, vedere IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Ereditato da MethodBase)
_MethodBase.IsFinal

Per una descrizione di questo membro, vedere IsFinal.For a description of this member, see IsFinal.

(Ereditato da MethodBase)
_MethodBase.IsHideBySig

Per una descrizione di questo membro, vedere IsHideBySig.For a description of this member, see IsHideBySig.

(Ereditato da MethodBase)
_MethodBase.IsPrivate

Per una descrizione di questo membro, vedere IsPrivate.For a description of this member, see IsPrivate.

(Ereditato da MethodBase)
_MethodBase.IsPublic

Per una descrizione di questo membro, vedere IsPublic.For a description of this member, see IsPublic.

(Ereditato da MethodBase)
_MethodBase.IsSpecialName

Per una descrizione di questo membro, vedere IsSpecialName.For a description of this member, see IsSpecialName.

(Ereditato da MethodBase)
_MethodBase.IsStatic

Per una descrizione di questo membro, vedere IsStatic.For a description of this member, see IsStatic.

(Ereditato da MethodBase)
_MethodBase.IsVirtual

Per una descrizione di questo membro, vedere IsVirtual.For a description of this member, see IsVirtual.

(Ereditato da MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (Ereditato da MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Ereditato da MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Ereditato da MemberInfo)

Metodi di estensione

GetCustomAttribute(MemberInfo, Type)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Indica se vengono applicati attributi personalizzati del tipo specificato a un membro specificato.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Indica se gli attributi personalizzati di un tipo specificato vengono applicati a un membro specificato e, facoltativamente, ai relativi predecessori.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Ottiene un token di metadati per il membro specificato, se disponibile.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Restituisce un valore che indica se un token di metadati è disponibile per il membro specificato.Returns a value that indicates whether a metadata token is available for the specified member.

Si applica a