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

Especificadores de uso do atributo permitem especificar destinos de atributo .Cada atributo é definido para aplicar a determinados elementos de linguagem.Por exemplo, um atributo poderão ser definidos aplicar apenas às classes e estruturas.A lista a seguir mostra os elementos sintáticos possíveis em que um atributo de personalizado pode ser usado.Combinações desses valores (usando lógica ou) pode ser usado.

Para especificar o atributodedestino, para passar um ou mais AttributeTargets enumeradores para AttributeUsageAttribute ao definir o atributo.

A seguir está uma lista de destinos deatributo válido:

// attribute_targets_all.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::All)]
ref class Attr : public Attribute {};
[assembly:Attr];

// attribute_targets_assembly.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Assembly)]
ref class Attr : public Attribute {};
[assembly:Attr];

// attribute_targets_module.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Module)]
ref class Attr : public Attribute {};
[module:Attr];

// attribute_targets_class.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Class)]
ref class Attr : public System::Attribute {};
[Attr]   // same as [class:Attr]
ref class MyClass {};

// attribute_targets_struct.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Struct)]
ref class Attr : public Attribute {};
[Attr]   // same as [struct:Attr]
value struct MyStruct{};

// attribute_targets_enum.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Enum)]
ref class Attr : public Attribute {};
[Attr]   // same as [enum:Attr]
enum struct MyEnum{e, d};

// attribute_targets_constructor.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Constructor)]
ref class Attr : public Attribute {};
ref struct MyStruct{
   [Attr] MyStruct(){}   // same as [constructor:Attr]
};

// attribute_targets_method.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Method)]
ref class Attr : public Attribute {};
ref struct MyStruct{
   [Attr] void Test(){}   // same as [method:Attr]
};

// attribute_targets_property.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Property)]
ref class Attr : public Attribute {};
ref struct MyStruct{
   [Attr] property int Test;   // same as [property:Attr]
};

// attribute_targets_field.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Field)]
ref class Attr : public Attribute {};
ref struct MyStruct{
   [Attr] int Test;   // same as [field:Attr]
};

// attribute_targets_event.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Event)]
ref class Attr : public Attribute {};
delegate void ClickEventHandler(int, double);
ref struct MyStruct{
   [Attr] event ClickEventHandler^ OnClick;   // same as [event:Attr]
};

// attribute_targets_interface.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Interface)]
ref class Attr : public Attribute {};
[Attr]   // same as [event:Attr]
interface struct MyStruct{};

// attribute_targets_parameter.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Parameter)]
ref class Attr : public Attribute {};
ref struct MyStruct{
   void Test([Attr] int i);
   void Test2([parameter:Attr] int i);
};

// attribute_targets_delegate.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Delegate)]
ref class Attr : public Attribute {};
[Attr] delegate void Test();
[delegate:Attr] delegate void Test2();

// attribute_targets_returnvalue.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::ReturnValue)]
ref class Attr : public Attribute {};
ref struct MyStruct {
   // Note required specifier
   [returnvalue:Attr] int Test() { return 0; }
};

Normalmente, um atributo diretamente precede o elemento de linguagem ao qual ele se aplica.Em alguns casos, no entanto, a posição de um atributo não é suficiente para determinar de pretendido do atributo destino.Considere este exemplo:

[Attr] int MyFn(double x)...

Sintaticamente, não há nenhuma maneira de saber se o atributo destina-se para aplicar o método ou o métododo valor retornado (neste maiúsculas e minúsculas, ele assumirá como o método).Em tais casos, um deusodo atributoespecificador pode ser usado. Por exemplo, para que o atributoaplicar o valor retornado, use o returnvalue especificador, da seguinte maneira:

[returnvalue:Attr] int MyFn(double x)... // applies to return value

Especificadores de uso do atributo são necessárias nas seguintes situações:

• Para especificar um móduloou assembly--nível de atributo.

• Para especificar que um atributo se aplica a um métododo valor retornado, não é o método:

  [method:Attr] int MyFn(double x)...     // Attr applies to method
  [returnvalue:Attr] int MyFn(double x)...// Attr applies to return value
  [Attr] int MyFn(double x)...            // default: method
  

• Para especificar que um atributo se aplica a uma propriedadedo acessador, não a propriedade:

  [method:MyAttr(123)] property int Property()  
  [property:MyAttr(123)] property int Property()
  [MyAttr(123)] property int get_MyPropy() // default: property
  

• Para especificar que um atributo se aplica a um eventodo acessador, não o evento:

  delegate void MyDel();
  ref struct X {
     [field:MyAttr(123)] event MyDel* MyEvent;   //field
     [event:MyAttr(123)] event MyDel* MyEvent;   //event
     [MyAttr(123)] event MyDel* MyEvent;   // default: event
  }
  

Umusodo atributoespecificador se aplica apenas ao atributo que segue imediatamente ou seja,

[returnvalue:Attr1, Attr2]

é diferente de

[returnvalue:Attr1, returnvalue:Attr2]

Exemplo

Descrição

Esse exemplo mostra como especificar vários destinos.

Código

// attribute_targets.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Class | AttributeTargets::Struct, AllowMultiple = true )]
ref struct Attr : public Attribute {
   Attr(bool i){}
   Attr(){}
};

[Attr]
ref class MyClass {};

[Attr]
[Attr(true)]
value struct MyStruct {};

Consulte também

Referência

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