Destinos de Atributos (Extensões de Componentes C++)
Artigo
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.
A seguir está uma lista de destinos deatributo válido:
Destino
Exemplo de uso
Todos
(se aplica a todas as construções)
// attribute_targets_all.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::All)]
ref class Attr : public Attribute {};
[assembly:Attr];
Assembly
(aplica-se a um assembly como um todo)
// attribute_targets_assembly.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Assembly)]
ref class Attr : public Attribute {};
[assembly:Attr];
Module
(aplica-se a um módulo como um todo)
// attribute_targets_module.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Module)]
ref class Attr : public Attribute {};
[module:Attr];
Classe
// 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 {};
Struct
// 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{};
Enum
// 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};
Construtor
// 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]
};
Método
// 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]
};
Propriedade
// 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]
};
Campo
// 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]
};
Evento
// 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]
};
Interface
// 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{};
Parâmetro
// 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);
};
Delegado
// 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();
ReturnValue
// 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:
.gif "ms177223.collapse_all(pt-br,VS.110).gif")
Descrição