Atributos Definidos pelo Usuário (Extensões de Componentes C++)

Atributos personalizados permitem que você estender os metadados de uma interface, classe ou estrutura, um método, um parâmetro, ou uma enumeração.

Qualquer tempo de execução

Qualquer tempo de execução suporta atributos personalizados.

Tempo de execução do windows

Atributos de C++/CX suportam apenas propriedades, mas não os construtores do atributo ou métodos.

Requisitos

Opção de compilador: /ZW

Common Language Runtime

Atributos personalizados permitem estender os metadados de um elemento gerenciado.Para obter mais informações, consulte Estendendo metadados usando atributos.

Comentários

A informações e a sintaxe apresentadas em este tópico são significadas substituir as informações apresentadas em atributo.

Você pode definir um atributo personalizado definindo um tipo e fazendo a Attribute uma classe base do tipo e opcionalmente aplicar o atributo de AttributeUsageAttribute .

Por exemplo, no servidor (MTS) 1,0 da Microsoft transaction, comportamento em relação às transações, sincronização, balanceamento de carga, foi especificado e assim por diante através de GUIDs personalizado inserido na biblioteca de tipos usando o atributo personalizado de ODL.Portanto, um cliente de um servidor MTS pode determinar as características ler a biblioteca de tipos.Em o .NET Framework, o analógico da biblioteca de tipos é metadados, e o analógico de atributo personalizado de ODL é atributos personalizados.Além de isso, leia a biblioteca de tipos é análogo ao usar reflexão em tipos.

Para obter mais informações, consulte,

• Destinos de Atributos (Extensões de Componentes C++)

• Tipos de Parâmetro de Atributo (Extensões de Componentes C++)

Para obter informações sobre como assinar assemblies no Visual C++, consulte Assemblies com nome forte (assinatura de Assembly) (C + + / CLI).

Requisitos

Opção de compilador: /clr

Exemplos

Exemplo

O exemplo a seguir mostra como definir um atributo personalizado.

// user_defined_attributes.cpp
// compile with: /clr /c
using namespace System;

[AttributeUsage(AttributeTargets::All)]
ref struct Attr : public Attribute {
   Attr(bool i){}
   Attr(){}
};

[Attr]
ref class MyClass {};

Exemplo

O seguinte exemplo mostra alguns recursos importantes de atributos personalizados.Por exemplo, este exemplo mostra um uso comum de atributos personalizados: criando uma instância de um servidor que se possa totalmente descrever para clientes.

// extending_metadata_b.cpp
// compile with: /clr
using namespace System;
using namespace System::Reflection;

public enum class Access { Read, Write, Execute };

// Defining the Job attribute:
[AttributeUsage(AttributeTargets::Class, AllowMultiple=true )]
public ref class Job : Attribute {
public:
   property int Priority {
      void set( int value ) { m_Priority = value; }
      int get() { return m_Priority; }
   }

   // You can overload constructors to specify Job attribute in different ways
   Job() { m_Access = Access::Read; }
   Job( Access a ) { m_Access = a; }
   Access m_Access;

protected:
   int m_Priority;
};

interface struct IService {
   void Run();
};

   // Using the Job attribute:
   // Here we specify that QueryService is to be read only with a priority of 2.
   // To prevent namespace collisions, all custom attributes implicitly 
   // end with "Attribute". 

[Job( Access::Read, Priority=2 )]
ref struct QueryService : public IService {
   virtual void Run() {}
};

// Because we said AllowMultiple=true, we can add multiple attributes 
[Job(Access::Read, Priority=1)]
[Job(Access::Write, Priority=3)]
ref struct StatsGenerator : public IService {
   virtual void Run( ) {}
};

int main() {
   IService ^ pIS;
   QueryService ^ pQS = gcnew QueryService;
   StatsGenerator ^ pSG = gcnew StatsGenerator;

   //  use QueryService
   pIS = safe_cast<IService ^>( pQS );

   // use StatsGenerator
   pIS = safe_cast<IService ^>( pSG );

   // Reflection
   MemberInfo ^ pMI = pIS->GetType();
   array <Object ^ > ^ pObjs = pMI->GetCustomAttributes(false);
   
   // We can now quickly and easily view custom attributes for an 
   // Object through Reflection */
   for( int i = 0; i < pObjs->Length; i++ ) {
      Console::Write("Service Priority = ");
      Console::WriteLine(static_cast<Job^>(pObjs[i])->Priority);
      Console::Write("Service Access = ");
      Console::WriteLine(static_cast<Job^>(pObjs[i])->m_Access);
   }
}

Saída

Exemplo

O tipo de Object^ substitui o tipo de dados variant.O seguinte exemplo define um atributo personalizado que leva uma matriz de Object^ como parâmetros.

Argumentos de atributo devem ser constantes de tempo de compilação; na maioria dos casos, devem ser literais constantes.

Consulte typeid (Extensões de Componentes C++) para obter informações sobre como retornar um valor de System::Type de um bloco de atributo personalizado.

// extending_metadata_e.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Class | AttributeTargets::Method)]
public ref class AnotherAttr : public Attribute {
public:
   AnotherAttr(array<Object^>^) {}
   array<Object^>^ var1;
};

// applying the attribute
[ AnotherAttr( gcnew array<Object ^> { 3.14159, "pi" }, var1 = gcnew array<Object ^> { "a", "b" } ) ]
public ref class SomeClass {};

Exemplo

O tempo de execução exige que a parte pública da classe de atributos personalizados devem ser serializáveis.A o criar atributos personalizados, os argumentos nomeados do seu atributo personalizado são associados às constantes de tempo de compilação.(Pense em ele como uma seqüência de bit anexados ao seu layout da classe nos metadados.)

// extending_metadata_f.cpp
// compile with: /clr /c
using namespace System;
ref struct abc {};

[AttributeUsage( AttributeTargets::All )]
ref struct A : Attribute {
   A( Type^ ) {}
   A( String ^ ) {}
   A( int ) {}
};

[A( abc::typeid )]
ref struct B {};

Consulte também

Conceitos

Extensões de componente para plataformas de tempo de execução