ConstructorBuilder Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Define y representa un constructor de una clase dinámica.
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
- Herencia
- Atributos
- Implementaciones
Ejemplos
En el ejemplo de código siguiente se muestra el uso contextual de .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
Comentarios
ConstructorBuilder se usa para describir completamente un constructor en el lenguaje intermedio de Microsoft (MSIL), incluidos el nombre, los atributos, la firma y el cuerpo del constructor. Se usa junto con la TypeBuilder clase para crear clases en tiempo de ejecución. Llame DefineConstructor a para obtener una instancia de ConstructorBuilder.
Si no define un constructor para el tipo dinámico, se proporciona automáticamente un constructor sin parámetros y llama al constructor sin parámetros de la clase base.
Si usa ConstructorBuilder para definir un constructor para el tipo dinámico, no se proporciona un constructor sin parámetros. Tiene las siguientes opciones para proporcionar un constructor sin parámetros además del constructor que ha definido:
Si desea un constructor sin parámetros que simplemente llame al constructor sin parámetros de la clase base, puede usar el TypeBuilder.DefineDefaultConstructor método para crear uno (y, opcionalmente, restringir el acceso a ella). No proporcione una implementación para este constructor sin parámetros. Si lo hace, se produce una excepción al intentar usar el constructor . No se produce ninguna excepción cuando se llama al TypeBuilder.CreateType método .
Si desea un constructor sin parámetros que haga algo más que simplemente llamar al constructor sin parámetros de la clase base, o que llame a otro constructor de la clase base, o que haga algo más por completo, debe usar el TypeBuilder.DefineConstructor método para crear un ConstructorBuildery proporcionar su propia implementación.
Constructores
ConstructorBuilder() |
Inicializa una nueva instancia de la clase ConstructorBuilder. |
Propiedades
Attributes |
Obtiene los atributos de este constructor. |
CallingConvention |
Obtiene un valor CallingConventions que depende de si el tipo declarativo es genérico. |
CallingConvention |
Obtiene un valor que indica las convenciones de llamada de este método. (Heredado de MethodBase) |
ContainsGenericParameters |
Obtiene un valor que indica si el método genérico contiene parámetros de tipo genérico sin asignar. (Heredado de MethodBase) |
CustomAttributes |
Obtiene una colección que contiene los atributos personalizados de este miembro. (Heredado de MemberInfo) |
DeclaringType |
Obtiene una referencia al objeto Type para el tipo que declara este miembro. |
InitLocals |
Obtiene o establece si las variables locales de este constructor deben inicializarse en cero. |
InitLocalsCore |
Cuando se invalida en una clase derivada, obtiene o establece un valor que indica si las variables locales de este constructor deben inicializarse en cero. |
IsAbstract |
Obtiene un valor que indica si el método es abstracto. (Heredado de MethodBase) |
IsAssembly |
Obtiene un valor que indica si Assembly describe la visibilidad posible de este método o constructor; es decir, el método o el constructor es visible como mucho para otros tipos del mismo ensamblado y no es visible para los tipos derivados fuera del ensamblado. (Heredado de MethodBase) |
IsCollectible |
Obtiene un valor que indica si este objeto MemberInfo forma parte de un ensamblado contenido en un AssemblyLoadContext recopilable. (Heredado de MemberInfo) |
IsConstructedGenericMethod |
Define y representa un constructor de una clase dinámica. (Heredado de MethodBase) |
IsConstructor |
Obtiene un valor que indica si el método es un constructor. (Heredado de MethodBase) |
IsFamily |
Obtiene un valor que indica si Family describe la visibilidad de este método o constructor; es decir, el método o el constructor sólo es visible dentro de su clase y clases derivadas. (Heredado de MethodBase) |
IsFamilyAndAssembly |
Obtiene un valor que indica si FamANDAssem describe la visibilidad de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor, pero sólo si están en el mismo ensamblado. (Heredado de MethodBase) |
IsFamilyOrAssembly |
Obtiene un valor que indica si FamORAssem describe la visibilidad posible de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor con independencia de dónde se encuentren, así como las clases del mismo ensamblado. (Heredado de MethodBase) |
IsFinal |
Obtiene un valor que indica si este método es |
IsGenericMethod |
Obtiene un valor que indica si el método es genérico. (Heredado de MethodBase) |
IsGenericMethodDefinition |
Obtiene un valor que indica si el método es una definición de método genérico. (Heredado de MethodBase) |
IsHideBySig |
Obtiene un valor que indica si sólo hay un miembro del mismo tipo y con idéntica firma oculto en la clase derivada. (Heredado de MethodBase) |
IsPrivate |
Obtiene un valor que indica si este miembro es privado. (Heredado de MethodBase) |
IsPublic |
Obtiene un valor que indica si éste es un método público. (Heredado de MethodBase) |
IsSecurityCritical |
Obtiene un valor que indica si el método o el constructor actual es crítico para la seguridad o es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas. (Heredado de MethodBase) |
IsSecuritySafeCritical |
Obtiene un valor que indica si el método o el constructor actual es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y está disponible desde código transparente. (Heredado de MethodBase) |
IsSecurityTransparent |
Obtiene un valor que indica si el método o el constructor actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas. (Heredado de MethodBase) |
IsSpecialName |
Obtiene un valor que indica si este método tiene un nombre especial. (Heredado de MethodBase) |
IsStatic |
Obtiene un valor que indica si el método es |
IsVirtual |
Obtiene un valor que indica si el método es |
MemberType |
Obtiene un valor de MemberTypes que indica que este miembro es un constructor. (Heredado de ConstructorInfo) |
MetadataToken |
Obtiene un token que identifica el módulo dinámico actual en los metadatos. |
MetadataToken |
Obtiene un valor que identifica un elemento de metadatos. (Heredado de MemberInfo) |
MethodHandle |
Obtiene el identificador interno para el método. Use este identificador para tener acceso al identificador de metadatos subyacente. |
MethodHandle |
Obtiene un identificador para la representación interna de metadatos de un método. (Heredado de MethodBase) |
MethodImplementationFlags |
Obtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método. |
MethodImplementationFlags |
Obtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método. (Heredado de MethodBase) |
Module |
Obtiene el módulo dinámico en el que se define este constructor. |
Module |
Obtiene el módulo en el que el tipo que declara el miembro representado por el objeto MemberInfo actual está definido. (Heredado de MemberInfo) |
Name |
Recupera el nombre de este constructor. |
ReflectedType |
Contiene una referencia al objeto Type del que se obtuvo este objeto. |
ReflectedType |
Obtiene el objeto de la clase utilizado para obtener esta instancia de |
ReturnType |
Obsoletos.
Obtiene |
Signature |
Recupera la firma del campo en el formulario de una cadena. |
Métodos
AddDeclarativeSecurity(SecurityAction, PermissionSet) |
Agrega seguridad declarativa a este constructor. |
DefineParameter(Int32, ParameterAttributes, String) |
Define un parámetro de este constructor. |
DefineParameterCore(Int32, ParameterAttributes, String) |
Cuando se reemplaza en una clase derivada, define un parámetro de este constructor. |
Equals(Object) |
Devuelve un valor que indica si esta instancia es igual que un objeto especificado. (Heredado de ConstructorInfo) |
GetCustomAttributes(Boolean) |
Devuelve todos los atributos personalizados definidos para este constructor. |
GetCustomAttributes(Boolean) |
Cuando se reemplaza en una clase derivada, devuelve una matriz de todos los atributos personalizados aplicados a este miembro. (Heredado de MemberInfo) |
GetCustomAttributes(Type, Boolean) |
Devuelve los atributos personalizados identificados por el tipo proporcionado. |
GetCustomAttributes(Type, Boolean) |
Cuando se invalida en una clase derivada, devuelve una matriz de atributos personalizados aplicados a este miembro e identificado por Type. (Heredado de MemberInfo) |
GetCustomAttributesData() |
Devuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se aplicaron al miembro de destino. (Heredado de MemberInfo) |
GetGenericArguments() |
Devuelve una matriz de objetos Type que representan los argumentos de tipo de un método genérico o los parámetros de tipo de una definición de método genérico. (Heredado de MethodBase) |
GetHashCode() |
Devuelve el código hash de esta instancia. (Heredado de ConstructorInfo) |
GetILGenerator() |
Obtiene un ILGenerator para este constructor. |
GetILGenerator(Int32) |
Obtiene un objeto ILGenerator, con el tamaño de secuencia MSIL especificado, que puede usarse para crear un cuerpo de método para este constructor. |
GetILGeneratorCore(Int32) |
Cuando se reemplaza en una clase derivada, obtiene un ILGenerator que se puede usar para emitir un cuerpo de método para este constructor. |
GetMethodBody() |
Cuando se reemplaza en una clase derivada, obtiene un objeto MethodBody que proporciona el acceso a la secuencia de MSIL, las variables locales y las excepciones del método actual. (Heredado de MethodBase) |
GetMethodImplementationFlags() |
Devuelve los marcadores de implementación del método para este constructor. |
GetMethodImplementationFlags() |
Cuando se reemplaza en una clase derivada, devuelve las marcas MethodImplAttributes. (Heredado de MethodBase) |
GetModule() |
Devuelve una referencia al módulo que contiene este constructor. |
GetParameters() |
Devuelve los parámetros de este constructor. |
GetToken() |
Devuelve el MethodToken que representa el token para este constructor. |
GetType() |
Detecta los atributos de un constructor de clase y proporciona acceso a los metadatos del constructor. (Heredado de ConstructorInfo) |
HasSameMetadataDefinitionAs(MemberInfo) |
Define y representa un constructor de una clase dinámica. (Heredado de MemberInfo) |
Invoke(BindingFlags, Binder, Object[], CultureInfo) |
Invoca dinámicamente al constructor representado por esta instancia en el objeto dado, pasando los parámetros especificados y considerando las restricciones del enlazador facilitado. |
Invoke(BindingFlags, Binder, Object[], CultureInfo) |
Al implementarse en una clase derivada, invoca al constructor reflejado por esta instancia de |
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Invoca dinámicamente el constructor reflejado por esta instancia con los argumentos especificados, bajo las restricciones del objeto |
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Cuando se reemplaza en una clase derivada, invoca el método o constructor reflejado con los parámetros especificados. (Heredado de MethodBase) |
Invoke(Object, Object[]) |
Invoca el método o constructor representado por la instancia actual, utilizando los parámetros especificados. (Heredado de MethodBase) |
Invoke(Object[]) |
Invoca al constructor reflejado por la instancia que tiene los parámetros especificados, proporcionando valores predeterminados para los parámetros que no se usan habitualmente. (Heredado de ConstructorInfo) |
IsDefined(Type, Boolean) |
Comprueba si se define el tipo de atributo personalizado especificado. |
IsDefined(Type, Boolean) |
Cuando se reemplaza en una clase derivada, indica si se aplican a este miembro uno o más atributos del tipo especificado o de sus tipos derivados. (Heredado de MemberInfo) |
MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
SetCustomAttribute(ConstructorInfo, Byte[]) |
Establece un atributo personalizado mediante un blob de atributo personalizado especificado. |
SetCustomAttribute(CustomAttributeBuilder) |
Establece un atributo personalizado mediante un generador de atributos personalizado. |
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>) |
Cuando se invalida en una clase derivada, establece un atributo personalizado en este constructor. |
SetImplementationFlags(MethodImplAttributes) |
Establece las marcas de implementación de método para este constructor. |
SetImplementationFlagsCore(MethodImplAttributes) |
Cuando se invalida en una clase derivada, establece las marcas de implementación del método para este constructor. |
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>) |
Crea el cuerpo del constructor con una matriz de bytes especificada de instrucciones de Lenguaje intermedio de Microsoft (MSIL). |
SetSymCustomAttribute(String, Byte[]) |
Establece el atributo personalizado de este constructor asociado a la información simbólica. |
ToString() |
Devuelve esta instancia de ConstructorBuilder como String. |
Implementaciones de interfaz explícitas
_ConstructorBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. |
_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz. |
_ConstructorBuilder.GetTypeInfoCount(UInt32) |
Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). |
_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Proporciona acceso a las propiedades y los métodos expuestos por un objeto. |
_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Heredado de ConstructorInfo) |
_ConstructorInfo.GetType() |
Obtiene un objeto Type que representa el tipo de ConstructorInfo. (Heredado de ConstructorInfo) |
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz. (Heredado de ConstructorInfo) |
_ConstructorInfo.GetTypeInfoCount(UInt32) |
Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). (Heredado de ConstructorInfo) |
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Proporciona acceso a las propiedades y los métodos expuestos por un objeto. (Heredado de ConstructorInfo) |
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo) |
Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object, BindingFlags, Binder, Object[], CultureInfo). (Heredado de ConstructorInfo) |
_ConstructorInfo.Invoke_3(Object, Object[]) |
Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object, Object[]). (Heredado de ConstructorInfo) |
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo) |
Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(BindingFlags, Binder, Object[], CultureInfo). (Heredado de ConstructorInfo) |
_ConstructorInfo.Invoke_5(Object[]) |
Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object[]). (Heredado de ConstructorInfo) |
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Heredado de MemberInfo) |
_MemberInfo.GetType() |
Objeto Type que representa la clase MemberInfo. (Heredado de MemberInfo) |
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz. (Heredado de MemberInfo) |
_MemberInfo.GetTypeInfoCount(UInt32) |
Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). (Heredado de MemberInfo) |
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Proporciona acceso a las propiedades y los métodos expuestos por un objeto. (Heredado de MemberInfo) |
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Heredado de MethodBase) |
_MethodBase.GetType() |
Para obtener una descripción de este miembro, vea GetType(). (Heredado de MethodBase) |
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz. (Heredado de MethodBase) |
_MethodBase.GetTypeInfoCount(UInt32) |
Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). (Heredado de MethodBase) |
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Proporciona acceso a las propiedades y los métodos expuestos por un objeto. (Heredado de MethodBase) |
_MethodBase.IsAbstract |
Para obtener una descripción de este miembro, vea IsAbstract. (Heredado de MethodBase) |
_MethodBase.IsAssembly |
Para obtener una descripción de este miembro, vea IsAssembly. (Heredado de MethodBase) |
_MethodBase.IsConstructor |
Para obtener una descripción de este miembro, vea IsConstructor. (Heredado de MethodBase) |
_MethodBase.IsFamily |
Para obtener una descripción de este miembro, vea IsFamily. (Heredado de MethodBase) |
_MethodBase.IsFamilyAndAssembly |
Para obtener una descripción de este miembro, vea IsFamilyAndAssembly. (Heredado de MethodBase) |
_MethodBase.IsFamilyOrAssembly |
Para obtener una descripción de este miembro, vea IsFamilyOrAssembly. (Heredado de MethodBase) |
_MethodBase.IsFinal |
Para obtener una descripción de este miembro, vea IsFinal. (Heredado de MethodBase) |
_MethodBase.IsHideBySig |
Para obtener una descripción de este miembro, vea IsHideBySig. (Heredado de MethodBase) |
_MethodBase.IsPrivate |
Para obtener una descripción de este miembro, vea IsPrivate. (Heredado de MethodBase) |
_MethodBase.IsPublic |
Para obtener una descripción de este miembro, vea IsPublic. (Heredado de MethodBase) |
_MethodBase.IsSpecialName |
Para obtener una descripción de este miembro, vea IsSpecialName. (Heredado de MethodBase) |
_MethodBase.IsStatic |
Para obtener una descripción de este miembro, vea IsStatic. (Heredado de MethodBase) |
_MethodBase.IsVirtual |
Para obtener una descripción de este miembro, vea IsVirtual. (Heredado de MethodBase) |
ICustomAttributeProvider.GetCustomAttributes(Boolean) |
Devuelve una matriz de todos los atributos personalizados definidos en este miembro, excluidos los atributos con nombre, o una matriz vacía si no hay atributos personalizados. (Heredado de MemberInfo) |
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) |
Devuelve una matriz de atributos personalizados definidos en este miembro, identificados por tipo, o una matriz vacía si no hay atributos personalizados de ese tipo. (Heredado de MemberInfo) |
ICustomAttributeProvider.IsDefined(Type, Boolean) |
Indica si una o más instancias de |
Métodos de extensión
GetCustomAttribute(MemberInfo, Type) |
Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. |
GetCustomAttribute(MemberInfo, Type, Boolean) |
Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. |
GetCustomAttribute<T>(MemberInfo) |
Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. |
GetCustomAttribute<T>(MemberInfo, Boolean) |
Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. |
GetCustomAttributes(MemberInfo) |
Recupera una colección de atributos personalizados que se aplican a un miembro especificado. |
GetCustomAttributes(MemberInfo, Boolean) |
Recupera una colección de atributos personalizados que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. |
GetCustomAttributes(MemberInfo, Type) |
Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. |
GetCustomAttributes(MemberInfo, Type, Boolean) |
Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. |
GetCustomAttributes<T>(MemberInfo) |
Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. |
GetCustomAttributes<T>(MemberInfo, Boolean) |
Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. |
IsDefined(MemberInfo, Type) |
Indica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado. |
IsDefined(MemberInfo, Type, Boolean) |
Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado y, opcionalmente, se aplican a sus antecesores. |
GetMetadataToken(MemberInfo) |
Obtiene un token de metadatos del miembro determinado, si está disponible. |
HasMetadataToken(MemberInfo) |
Devuelve un valor que indica si un token de metadatos está disponible para el miembro especificado. |