Attributs définis par l’utilisateur (C++/CLI et C++/CX)User-Defined Attributes (C++/CLI and C++/CX)

C++/CLI et C++/CX permettent de créer des attributs spécifiques à la plateforme qui étendent les métadonnées d’une interface, d’une classe ou structure, d’une méthode, d’un paramètre ou d’une énumération.C++/CLI and C++/CX enable you to create platform-specific attributes that extend the metadata of an interface, class or structure, method, parameter, or enumeration. Ces attributs sont différents des attributs C++ standard.These attributes are distinct from the standard C++ attributes.

Windows RuntimeWindows Runtime

Vous pouvez appliquer des attributs C++/CX aux propriétés, mais pas aux constructeurs ou aux méthodes.You can apply C++/CX attributes to properties, but not to constructors or methods.

SpécificationsRequirements

Option du compilateur : /ZWCompiler option: /ZW

Common Language RuntimeCommon Language Runtime

Les informations et la syntaxe présentées dans cette rubrique doivent remplacer les informations présentées dans Attributs.The information and syntax presented in this topic is meant to supersede the information presented in attribute.

Vous pouvez définir un attribut personnalisé en définissant un type, en faisant de Attribute une classe de base pour le type, et en appliquant éventuellement l’attribut AttributeUsageAttribute.You can define a custom attribute by defining a type and making Attribute a base class for the type and optionally applying the AttributeUsageAttribute attribute.

Pour plus d'informations, consultez les pages suivantes :For more information, see:

Pour plus d’informations sur la signature d’assemblys dans Visual C++, consultez Assemblys de nom fort (signature d’assembly) (C++/CLI).For information on signing assemblies in Visual C++, see Strong Name Assemblies (Assembly Signing) (C++/CLI).

SpécificationsRequirements

Option du compilateur : /clrCompiler option: /clr

ExemplesExamples

L’exemple suivant montre comment définir un attribut personnalisé.The following sample shows how to define a custom attribute.

// 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 {};

L’exemple suivant illustre certaines fonctionnalités importantes des attributs personnalisés.The following example illustrates some important features of custom attributes. Par exemple, l’exemple suivant montre une utilisation courante des attributs personnalisés : l’instanciation d’un serveur qui peut se décrire complètement aux clients.For example, this example shows a common usage of the custom attributes: instantiating a server that can fully describe itself to clients.

// 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);
   }
}
Service Priority = 0

Service Access = Write

Service Priority = 3

Service Access = Write

Service Priority = 1

Service Access = Read

Le type Object^ remplace le type de données variant. L’exemple suivant définit un attribut personnalisé qui prend un tableau de Object^ en tant que paramètres.The following example defines a custom attribute that takes an array of Object^ as parameters.

Les arguments d’attributs doivent être des constantes au moment de la compilation. Dans la plupart des cas, ils doivent être des littéraux constants.Attribute arguments must be compile-time constants; in most cases, they should be constant literals.

Consultez typeid pour plus d’informations sur la manière de retourner une valeur System::Type depuis un bloc d’attributs personnalisés.See typeid for information on how to return a value of System::Type from a custom attribute block.

// 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 {};

Le runtime nécessite que la partie publique de la classe d’attributs personnalisés soit sérialisable.The runtime requires that the public part of the custom attribute class must be serializable. Lors de la création d’attributs personnalisés, les arguments nommés de l’attribut personnalisé sont limités aux constantes au moment de la compilation.When authoring custom attributes, named arguments of your custom attribute are limited to compile-time constants. (Il s’agit d’une séquence de bits ajoutée à votre disposition de classe dans les métadonnées.)(Think of it as a sequence of bits appended to your class layout in the metadata.)

// 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 {};

Voir aussiSee also

Extensions de composant pour .NET et UWPComponent Extensions for .NET and UWP