PropertyBuilder Classe

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Origem:

PropertyBuilder.cs

Define as propriedades de um tipo.

public ref class PropertyBuilder abstract : System::Reflection::PropertyInfo

public abstract class PropertyBuilder : System.Reflection.PropertyInfo

type PropertyBuilder = class
    inherit PropertyInfo

Public MustInherit Class PropertyBuilder
Inherits PropertyInfo

Herança

Object

MemberInfo

PropertyInfo

PropertyBuilder

Exemplos

O exemplo de código a seguir demonstra como implementar propriedades em um tipo dinâmico usando um PropertyBuilder obtido por meio TypeBuilder.DefineProperty de para criar a estrutura de propriedades e um associado MethodBuilder para implementar a lógica IL dentro da propriedade .

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildDynamicTypeWithProperties()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   
   // To generate a persistable assembly, specify AssemblyBuilderAccess::RunAndSave.
   AssemblyBuilder^ myAsmBuilder = 
       myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
   
   // Generate a persistable single-module assembly.
   ModuleBuilder^ myModBuilder = 
       myAsmBuilder->DefineDynamicModule( myAsmName->Name, myAsmName->Name + ".dll" );
   TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( "CustomerData", TypeAttributes::Public );

   // Define a private field to hold the property value.
   FieldBuilder^ customerNameBldr = myTypeBuilder->DefineField( "customerName", String::typeid, FieldAttributes::Private );
   
   // The last argument of DefineProperty is an empty array of Type
   // objects, because the property has no parameters. (Alternatively,
   // you can specify a null value.)
   PropertyBuilder^ custNamePropBldr = 
       myTypeBuilder->DefineProperty( "CustomerName", PropertyAttributes::HasDefault, String::typeid, gcnew array<Type^>(0) );
   
   // The property set and property get methods require a special
   // set of attributes.
   MethodAttributes getSetAttr = 
       MethodAttributes::Public | MethodAttributes::SpecialName |
           MethodAttributes::HideBySig;

   // Define the "get" accessor method for CustomerName.
   MethodBuilder^ custNameGetPropMthdBldr = 
       myTypeBuilder->DefineMethod( "get_CustomerName", 
                                    getSetAttr,
                                    String::typeid, 
                                    Type::EmptyTypes );

   ILGenerator^ custNameGetIL = custNameGetPropMthdBldr->GetILGenerator();
   custNameGetIL->Emit( OpCodes::Ldarg_0 );
   custNameGetIL->Emit( OpCodes::Ldfld, customerNameBldr );
   custNameGetIL->Emit( OpCodes::Ret );
   
   // Define the "set" accessor method for CustomerName.
   array<Type^>^temp2 = {String::typeid};
   MethodBuilder^ custNameSetPropMthdBldr = 
       myTypeBuilder->DefineMethod( "set_CustomerName", 
                                    getSetAttr,
                                    nullptr, 
                                    temp2 );

   ILGenerator^ custNameSetIL = custNameSetPropMthdBldr->GetILGenerator();
   custNameSetIL->Emit( OpCodes::Ldarg_0 );
   custNameSetIL->Emit( OpCodes::Ldarg_1 );
   custNameSetIL->Emit( OpCodes::Stfld, customerNameBldr );
   custNameSetIL->Emit( OpCodes::Ret );
   
   // Last, we must map the two methods created above to our PropertyBuilder to
   // their corresponding behaviors, "get" and "set" respectively.
   custNamePropBldr->SetGetMethod( custNameGetPropMthdBldr );
   custNamePropBldr->SetSetMethod( custNameSetPropMthdBldr );

   Type^ retval = myTypeBuilder->CreateType();

   // Save the assembly so it can be examined with Ildasm.exe,
   // or referenced by a test program.
   myAsmBuilder->Save(myAsmName->Name + ".dll");
   return retval;
}

int main()
{
   Type^ custDataType = BuildDynamicTypeWithProperties();
   array<PropertyInfo^>^custDataPropInfo = custDataType->GetProperties();
   System::Collections::IEnumerator^ myEnum = custDataPropInfo->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      PropertyInfo^ pInfo = safe_cast<PropertyInfo^>(myEnum->Current);
      Console::WriteLine( "Property '{0}' created!", pInfo );
   }

   Console::WriteLine( "---" );
   
   // Note that when invoking a property, you need to use the proper BindingFlags -
   // BindingFlags::SetProperty when you invoke the "set" behavior, and
   // BindingFlags::GetProperty when you invoke the "get" behavior. Also note that
   // we invoke them based on the name we gave the property, as expected, and not
   // the name of the methods we bound to the specific property behaviors.
   Object^ custData = Activator::CreateInstance( custDataType );
   array<Object^>^temp3 = {"Joe User"};
   custDataType->InvokeMember( "CustomerName", BindingFlags::SetProperty, nullptr, custData, temp3 );
   Console::WriteLine( "The customerName field of instance custData has been set to '{0}'.", custDataType->InvokeMember( "CustomerName", BindingFlags::GetProperty, nullptr, custData, gcnew array<Object^>(0) ) );
}

// --- O U T P U T ---
// The output should be as follows:
// -------------------
// Property 'System.String CustomerName' created!
// ---
// The customerName field of instance custData has been set to 'Joe User'.
// -------------------

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class PropertyBuilderDemo
{
   public static Type BuildDynamicTypeWithProperties()
   {
        AppDomain myDomain = Thread.GetDomain();
        AssemblyName myAsmName = new AssemblyName();
        myAsmName.Name = "MyDynamicAssembly";

        // To generate a persistable assembly, specify AssemblyBuilderAccess.RunAndSave.
        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,
                                                        AssemblyBuilderAccess.RunAndSave);
        // Generate a persistable single-module assembly.
        ModuleBuilder myModBuilder =
            myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");

        TypeBuilder myTypeBuilder = myModBuilder.DefineType("CustomerData",
                                                        TypeAttributes.Public);

        FieldBuilder customerNameBldr = myTypeBuilder.DefineField("customerName",
                                                        typeof(string),
                                                        FieldAttributes.Private);

        // The last argument of DefineProperty is null, because the
        // property has no parameters. (If you don't specify null, you must
        // specify an array of Type objects. For a parameterless property,
        // use an array with no elements: new Type[] {})
        PropertyBuilder custNamePropBldr = myTypeBuilder.DefineProperty("CustomerName",
                                                         PropertyAttributes.HasDefault,
                                                         typeof(string),
                                                         null);

        // The property set and property get methods require a special
        // set of attributes.
        MethodAttributes getSetAttr =
            MethodAttributes.Public | MethodAttributes.SpecialName |
                MethodAttributes.HideBySig;

        // Define the "get" accessor method for CustomerName.
        MethodBuilder custNameGetPropMthdBldr =
            myTypeBuilder.DefineMethod("get_CustomerName",
                                       getSetAttr,
                                       typeof(string),
                                       Type.EmptyTypes);

        ILGenerator custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();

        custNameGetIL.Emit(OpCodes.Ldarg_0);
        custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
        custNameGetIL.Emit(OpCodes.Ret);

        // Define the "set" accessor method for CustomerName.
        MethodBuilder custNameSetPropMthdBldr =
            myTypeBuilder.DefineMethod("set_CustomerName",
                                       getSetAttr,
                                       null,
                                       new Type[] { typeof(string) });

        ILGenerator custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();

        custNameSetIL.Emit(OpCodes.Ldarg_0);
        custNameSetIL.Emit(OpCodes.Ldarg_1);
        custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);
        custNameSetIL.Emit(OpCodes.Ret);

        // Last, we must map the two methods created above to our PropertyBuilder to
        // their corresponding behaviors, "get" and "set" respectively.
        custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);
        custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);

        Type retval = myTypeBuilder.CreateType();

        // Save the assembly so it can be examined with Ildasm.exe,
        // or referenced by a test program.
        myAsmBuilder.Save(myAsmName.Name + ".dll");
        return retval;
   }

   public static void Main()
   {
        Type custDataType = BuildDynamicTypeWithProperties();

        PropertyInfo[] custDataPropInfo = custDataType.GetProperties();
        foreach (PropertyInfo pInfo in custDataPropInfo) {
           Console.WriteLine("Property '{0}' created!", pInfo.ToString());
        }

        Console.WriteLine("---");
        // Note that when invoking a property, you need to use the proper BindingFlags -
        // BindingFlags.SetProperty when you invoke the "set" behavior, and
        // BindingFlags.GetProperty when you invoke the "get" behavior. Also note that
        // we invoke them based on the name we gave the property, as expected, and not
        // the name of the methods we bound to the specific property behaviors.

        object custData = Activator.CreateInstance(custDataType);
        custDataType.InvokeMember("CustomerName", BindingFlags.SetProperty,
                                      null, custData, new object[]{ "Joe User" });

        Console.WriteLine("The customerName field of instance custData has been set to '{0}'.",
                           custDataType.InvokeMember("CustomerName", BindingFlags.GetProperty,
                                                      null, custData, new object[]{ }));
   }
}

// --- O U T P U T ---
// The output should be as follows:
// -------------------
// Property 'System.String CustomerName' created!
// ---
// The customerName field of instance custData has been set to 'Joe User'.
// -------------------

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

Class PropertyBuilderDemo
   
   Public Shared Function BuildDynamicTypeWithProperties() As Type
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      ' To generate a persistable assembly, specify AssemblyBuilderAccess.RunAndSave.
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                                                        AssemblyBuilderAccess.RunAndSave)
      
      ' Generate a persistable, single-module assembly.
      Dim myModBuilder As ModuleBuilder = _
          myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name & ".dll")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("CustomerData", TypeAttributes.Public)
      
      ' Define a private field to hold the property value.
      Dim customerNameBldr As FieldBuilder = myTypeBuilder.DefineField("customerName", _
                                             GetType(String), FieldAttributes.Private)
      
      ' The last argument of DefineProperty is Nothing, because the
      ' property has no parameters. (If you don't specify Nothing, you must
      ' specify an array of Type objects. For a parameterless property,
      ' use an array with no elements: New Type() {})
      Dim custNamePropBldr As PropertyBuilder = _
          myTypeBuilder.DefineProperty("CustomerName", _
                                       PropertyAttributes.HasDefault, _
                                       GetType(String), _
                                       Nothing)
      
      ' The property set and property get methods require a special
      ' set of attributes.
      Dim getSetAttr As MethodAttributes = _
          MethodAttributes.Public Or MethodAttributes.SpecialName _
              Or MethodAttributes.HideBySig

      ' Define the "get" accessor method for CustomerName.
      Dim custNameGetPropMthdBldr As MethodBuilder = _
          myTypeBuilder.DefineMethod("GetCustomerName", _
                                     getSetAttr, _
                                     GetType(String), _
                                     Type.EmptyTypes)
      
      Dim custNameGetIL As ILGenerator = custNameGetPropMthdBldr.GetILGenerator()
      
      custNameGetIL.Emit(OpCodes.Ldarg_0)
      custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr)
      custNameGetIL.Emit(OpCodes.Ret)
      
      ' Define the "set" accessor method for CustomerName.
      Dim custNameSetPropMthdBldr As MethodBuilder = _
          myTypeBuilder.DefineMethod("get_CustomerName", _
                                     getSetAttr, _
                                     Nothing, _
                                     New Type() {GetType(String)})
      
      Dim custNameSetIL As ILGenerator = custNameSetPropMthdBldr.GetILGenerator()
      
      custNameSetIL.Emit(OpCodes.Ldarg_0)
      custNameSetIL.Emit(OpCodes.Ldarg_1)
      custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr)
      custNameSetIL.Emit(OpCodes.Ret)
      
      ' Last, we must map the two methods created above to our PropertyBuilder to 
      ' their corresponding behaviors, "get" and "set" respectively. 
      custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr)
      custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr)
            
      Dim retval As Type = myTypeBuilder.CreateType()

      ' Save the assembly so it can be examined with Ildasm.exe,
      ' or referenced by a test program.
      myAsmBuilder.Save(myAsmName.Name & ".dll")
      return retval
   End Function 'BuildDynamicTypeWithProperties
    
   
   Public Shared Sub Main()
      Dim custDataType As Type = BuildDynamicTypeWithProperties()
      
      Dim custDataPropInfo As PropertyInfo() = custDataType.GetProperties()
      Dim pInfo As PropertyInfo
      For Each pInfo In  custDataPropInfo
         Console.WriteLine("Property '{0}' created!", pInfo.ToString())
      Next pInfo
      
      Console.WriteLine("---")
      ' Note that when invoking a property, you need to use the proper BindingFlags -
      ' BindingFlags.SetProperty when you invoke the "set" behavior, and 
      ' BindingFlags.GetProperty when you invoke the "get" behavior. Also note that
      ' we invoke them based on the name we gave the property, as expected, and not
      ' the name of the methods we bound to the specific property behaviors.
      Dim custData As Object = Activator.CreateInstance(custDataType)
      custDataType.InvokeMember("CustomerName", BindingFlags.SetProperty, Nothing, _
                                custData, New Object() {"Joe User"})
      
      Console.WriteLine("The customerName field of instance custData has been set to '{0}'.", _
                        custDataType.InvokeMember("CustomerName", BindingFlags.GetProperty, _
                        Nothing, custData, New Object() {}))
   End Sub
End Class


' --- O U T P U T ---
' The output should be as follows:
' -------------------
' Property 'System.String CustomerName' created!
' ---
' The customerName field of instance custData has been set to 'Joe User'.
' -------------------

Comentários

Um PropertyBuilder é sempre associado a um TypeBuilder. O TypeBuilder. DefineProperty o método retornará um novo PropertyBuilder para um cliente.

Construtores

PropertyBuilder()

Inicializa uma nova instância da classe PropertyBuilder.

Propriedades

Attributes	Obtém os atributos desta propriedade.
CanRead	Obtém um valor que indica se a propriedade pode ser lida.
CanWrite	Obtém um valor que indica se a propriedade pode ser usada para gravação.
CustomAttributes	Obtém uma coleção que contém os atributos personalizados desse membro. (Herdado de MemberInfo)
DeclaringType	Obtém a classe que declara esse membro.
GetMethod	Obtém o acessador get dessa propriedade. (Herdado de PropertyInfo)
IsCollectible	Obtém um valor que indica se este objeto MemberInfo faz parte de um assembly mantido em uma coleção AssemblyLoadContext. (Herdado de MemberInfo)
IsSpecialName	Obtém um valor que indica se a propriedade é o nome especial. (Herdado de PropertyInfo)
MemberType	Obtém um valor MemberTypes que indica que este membro é uma propriedade. (Herdado de PropertyInfo)
MetadataToken	Obtém um valor que identifica um elemento de metadados. (Herdado de MemberInfo)
Module	Obtém o módulo no qual o tipo que declara a propriedade atual está sendo definido.
Name	Obtém o nome desse membro.
PropertyType	Obtém o tipo do campo dessa propriedade.
ReflectedType	Obtém o objeto de classe que foi usado para obter esta instância de MemberInfo.
SetMethod	Obtém o acessador set dessa propriedade. (Herdado de PropertyInfo)

Métodos

AddOtherMethod(MethodBuilder)	Adiciona um dos outros métodos associados a essa propriedade.
AddOtherMethodCore(MethodBuilder)	Quando substituído em uma classe derivada, adiciona um dos outros métodos associados a essa propriedade.
Equals(Object)	Retorna um valor que indica se essa instância é igual a um objeto especificado. (Herdado de PropertyInfo)
GetAccessors()	Retorna uma matriz cujos elementos refletem os acessadores get e set públicos da propriedade refletida pela instância atual. (Herdado de PropertyInfo)
GetAccessors(Boolean)	Retorna uma matriz de acessadores get e set públicos e não públicos nesta propriedade.
GetConstantValue()	Retorna um valor literal associado à propriedade por um compilador. (Herdado de PropertyInfo)
GetCustomAttributes(Boolean)	Retorna uma matriz de todos os atributos personalizados para essa propriedade.
GetCustomAttributes(Type, Boolean)	Retorna uma matriz de atributos personalizados identificados por Type.
GetCustomAttributesData()	Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino. (Herdado de MemberInfo)
GetGetMethod()	Retorna o acessador get público para essa propriedade. (Herdado de PropertyInfo)
GetGetMethod(Boolean)	Retorna o acessador get público e não público para essa propriedade.
GetHashCode()	Retorna o código hash para a instância. (Herdado de PropertyInfo)
GetIndexParameters()	Retorna uma matriz de todos os parâmetros de índice para a propriedade.
GetModifiedPropertyType()	Obtém o tipo modificado desse objeto de propriedade. (Herdado de PropertyInfo)
GetOptionalCustomModifiers()	Retorna uma matriz de tipos que representam os modificadores personalizados opcionais da propriedade. (Herdado de PropertyInfo)
GetRawConstantValue()	Retorna um valor literal associado à propriedade por um compilador. (Herdado de PropertyInfo)
GetRequiredCustomModifiers()	Retorna uma matriz de tipos que representam os modificadores personalizados necessários da propriedade. (Herdado de PropertyInfo)
GetSetMethod()	Retorna o acessador set público para essa propriedade. (Herdado de PropertyInfo)
GetSetMethod(Boolean)	Retorna o acessador set para essa propriedade.
GetType()	Descobre os atributos de uma propriedade e fornece acesso aos parâmetros da propriedade. (Herdado de PropertyInfo)
GetValue(Object)	Retorna o valor da propriedade de um objeto especificado. (Herdado de PropertyInfo)
GetValue(Object, BindingFlags, Binder, Object[], CultureInfo)	Obtém o valor de uma propriedade com a associação, o índice e o CultureInfo especificados.
GetValue(Object, Object[])	Obtém o valor da propriedade indexada chamando o método getter da propriedade.
HasSameMetadataDefinitionAs(MemberInfo)	Define as propriedades de um tipo. (Herdado de MemberInfo)
IsDefined(Type, Boolean)	Indica se uma ou mais instância de attributeType está definida nessa propriedade.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
SetConstant(Object)	Define o valor padrão dessa propriedade.
SetConstantCore(Object)	Quando substituído em uma classe derivada, define o valor padrão dessa propriedade.
SetCustomAttribute(ConstructorInfo, Byte[])	Define um atributo personalizado usando um blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Defina um atributo personalizado usando um construtor de atributos personalizados.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, define um atributo personalizado neste assembly.
SetGetMethod(MethodBuilder)	Define o método que obtém o valor da propriedade.
SetGetMethodCore(MethodBuilder)	Quando substituído em uma classe derivada, define o método que obtém o valor da propriedade.
SetSetMethod(MethodBuilder)	Define o método que define o valor da propriedade.
SetSetMethodCore(MethodBuilder)	Quando substituído em uma classe derivada, define o método que define o valor da propriedade.
SetValue(Object, Object)	Define o valor da propriedade de um objeto especificado. (Herdado de PropertyInfo)
SetValue(Object, Object, BindingFlags, Binder, Object[], CultureInfo)	Define o valor da propriedade para o objeto fornecido para o valor fornecido.
SetValue(Object, Object, Object[])	Define o valor da propriedade com valores de índice opcionais para propriedades do índice.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Métodos de Extensão

GetCustomAttribute(MemberInfo, Type)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttribute<T>(MemberInfo)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo)	Recupera uma coleção de atributos personalizados que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo, Type)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes<T>(MemberInfo)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
IsDefined(MemberInfo, Type)	Indica se os atributos personalizados de um tipo especificados são aplicados a um membro especificado.
IsDefined(MemberInfo, Type, Boolean)	Indica se os atributos personalizados de um tipo especificado são aplicados a um membro especificado e, opcionalmente, aplicados a seus ancestrais.
GetMetadataToken(MemberInfo)	Obtém um token de metadados para o membro fornecido, se disponível.
HasMetadataToken(MemberInfo)	Retorna um valor que indica se um token de metadados está disponível para o membro especificado.
GetAccessors(PropertyInfo)	Define as propriedades de um tipo.
GetAccessors(PropertyInfo, Boolean)	Define as propriedades de um tipo.
GetGetMethod(PropertyInfo)	Define as propriedades de um tipo.
GetGetMethod(PropertyInfo, Boolean)	Define as propriedades de um tipo.
GetSetMethod(PropertyInfo)	Define as propriedades de um tipo.
GetSetMethod(PropertyInfo, Boolean)	Define as propriedades de um tipo.