Specyfikatory użycia atrybutu pozwalają określić cele atrybutu. Każdy atrybut jest zdefiniowany do zastosowania do niektórych elementów języka.Na przykład można zdefiniować atrybutu do zastosowania tylko do klas i strukturach. Na poniższej liście przedstawiono możliwe elementy składni, w których można użyć atrybutu niestandardowego.Kombinacje tych wartości (przy użyciu logicznych lub) mogą być używane.
Oto lista miejsc docelowych nieprawidłowy atrybut:
Docelowy
Przykładowe użycie
Wszystkie
(dotyczy wszystkich konstrukcje)
// attribute_targets_all.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::All)]
ref class Attr : public Attribute {};
[assembly:Attr];
Zestaw
(dotyczy zestawu jako całości)
// attribute_targets_assembly.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Assembly)]
ref class Attr : public Attribute {};
[assembly:Attr];
Moduł
(dotyczy do modułu jako całości)
// attribute_targets_module.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Module)]
ref class Attr : public Attribute {};
[module:Attr];
Klasa
// 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 {};
struktura
// 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{};
wyliczenia
// 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};
Konstruktor
// 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]
};
Metoda
// 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]
};
Właściwość
// 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]
};
Pole
// 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]
};
Zdarzenie
// 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]
};
Interfejs
// 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{};
Parametr
// 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);
};
Obiekt delegowany
// 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; }
};
Atrybut bezpośrednio poprzedza zazwyczaj element języka, do którego ma zastosowanie.W niektórych przypadkach, stanowisko atrybutu nie jest wystarczające do określenia atrybutu zamierzony cel.Spójrzmy na następujący przykład:
[Attr] int MyFn(double x)...
Syntaktycznie, nie istnieje sposób stwierdzić, jeśli atrybut jest przeznaczony do zastosowania do metody lub metoda zwraca wartość (w tym przypadku domyślnie metoda).W takich przypadkach dopuszcza się specyfikatorze atrybutu użycia.Na przykład, aby atrybut obowiązywał dla wartości zwracanej, należy użyć returnvalue specyfikatora, w następujący sposób:
[returnvalue:Attr] int MyFn(double x)... // applies to return value
Specyfikatory użycia atrybutu są wymagane w następujących sytuacjach:
Aby określić atrybut poziom zestawu lub modułu.
Aby określić, że atrybut jest stosowana do metoda zwraca wartość, nie metoda:
[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
Aby określić, że atrybut jest stosowana do akcesor właściwości, nie właściwość:
[method:MyAttr(123)] property int Property()
[property:MyAttr(123)] property int Property()
[MyAttr(123)] property int get_MyPropy() // default: property
Aby określić, że atrybut jest stosowana do akcesorów zdarzeń, nie zdarzenia: