Les spécificateurs d'utilisation d'attributs permettent de spécifier des cibles d'attribut. Chaque attribut est défini pour s'appliquer à certains éléments de langage. Par exemple, un attribut peut être défini pour s'appliquer aux classes et aux structs. La liste suivante présente les éléments syntaxiques possibles sur lesquels l'attribut personnalisé peut être utilisé. Les combinaisons de valeurs suivantes (avec logique ou) peuvent être utilisées.
Pour spécifier la cible d'attribut, pour transmettre une ou plusieurs des énumérateurs AttributeTargets à AttributeUsageAttribute en définissant l'attribut.
Voici une liste des cibles valides d'attribut :
Cible
Utilisation de l'exemple
Tous
(s'applique à tous les éléments)
// attribute_targets_all.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::All)]
ref class Attr : public Attribute {};
[assembly:Attr];
Assembly
(s'applique à un assembly dans son ensemble)
// attribute_targets_assembly.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Assembly)]
ref class Attr : public Attribute {};
[assembly:Attr];
Module
(s'applique à un module dans son ensemble)
// 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};
Constructeur
// 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éthode
// 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]
};
Propriété
// 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]
};
Champ
// 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]
};
Événement
// 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{};
Paramètre
// 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);
};
Délégué
// 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();
Valeur de Retour
// 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; }
};
En général, un attribut précède directement l'élément language du fichier auquel il s'applique. Toutefois, dans certains cas, la position d'un attribut n'est pas suffisante pour déterminer la cible prévue de l'attribut. Considérez cet exemple :
[Attr] int MyFn(double x)...
Syntaxiquement, il est impossible de déterminer si l'attribut est destiné à appliquer à la méthode ou la valeur de retour de la méthode (dans ce cas, il prend la méthode par défaut). Dans des cas pareils, un spécificateur d'utilisation d'attributs peut être utilisé. Par exemple, pour que l'attribut s'applique à la valeur de retour, utilisez le spécificateur returnvalue, comme suit :
[returnvalue:Attr] int MyFn(double x)... // applies to return value
Les spécificateurs d'utilisation d'attributs sont requis dans les cas suivants :
Pour spécifier un assembly ou un attribut de niveau module.
Pour spécifier qu'un attribut s'applique à la valeur de retour d'une méthode, et non la méthode :
[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
Pour spécifier qu'un attribut s'applique à l'accesseur de propriété, et non la propriété :
[method:MyAttr(123)] property int Property()
[property:MyAttr(123)] property int Property()
[MyAttr(123)] property int get_MyPropy() // default: property
Pour spécifier qu'un attribut s'applique à l'accesseur d'un événement, et non l'événement :