Cíle atributů (C++/CLI a C++/CX)

Specifikátory použití atributů umožňují zadat cíle atributů. Každý atribut je definován tak, aby se použil na určité prvky jazyka. Například atribut může být definován tak, aby se použil pouze na třídy a struktury. Následující seznam ukazuje možné syntaktické prvky, na kterých lze použít vlastní atribut. Můžete použít kombinace těchto hodnot (pomocí logického nebo).

Chcete-li určit cíl atributu, předat jeden nebo více AttributeTargets enumerátorů při AttributeUsageAttribute definování atributu.

Následuje seznam platných cílů atributů:

• All (platí pro všechny konstrukce)

  using namespace System;
  [AttributeUsage(AttributeTargets::All)]
  ref class Attr : public Attribute {};
  
  [assembly:Attr];
  

• Assembly (platí pro sestavení jako celek)

  using namespace System;
  [AttributeUsage(AttributeTargets::Assembly)]
  ref class Attr : public Attribute {};
  
  [assembly:Attr];
  

• Module (platí pro modul jako celek)

  using namespace System;
  [AttributeUsage(AttributeTargets::Module)]
  ref class Attr : public Attribute {};
  
  [module:Attr];
  

• Class

  using namespace System;
  [AttributeUsage(AttributeTargets::Class)]
  ref class Attr : public System::Attribute {};
  
  [Attr]   // same as [class:Attr]
  ref class MyClass {};
  

• Struct

  using namespace System;
  [AttributeUsage(AttributeTargets::Struct)]
  ref class Attr : public Attribute {};
  
  [Attr]   // same as [struct:Attr]
  value struct MyStruct{};
  

• enum

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

• Constructor

  using namespace System;
  [AttributeUsage(AttributeTargets::Constructor)]
  ref class Attr : public Attribute {};
  
  ref struct MyStruct{
  [Attr] MyStruct(){}   // same as [constructor:Attr]
  };
  

• Method

  using namespace System;
  [AttributeUsage(AttributeTargets::Method)]
  ref class Attr : public Attribute {};
  
  ref struct MyStruct{
  [Attr] void Test(){}   // same as [method:Attr]
  };
  

• Property

  using namespace System;
  [AttributeUsage(AttributeTargets::Property)]
  ref class Attr : public Attribute {};
  
  ref struct MyStruct{
  [Attr] property int Test;   // same as [property:Attr]
  };
  

• Field

  using namespace System;
  [AttributeUsage(AttributeTargets::Field)]
  ref class Attr : public Attribute {};
  
  ref struct MyStruct{
  [Attr] int Test;   // same as [field:Attr]
  };
  

• Event

  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

  using namespace System;
  [AttributeUsage(AttributeTargets::Interface)]
  ref class Attr : public Attribute {};
  
  [Attr]   // same as [event:Attr]
  interface struct MyStruct{};
  

• Parameter

  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);
  };
  

• Delegate

  using namespace System;
  [AttributeUsage(AttributeTargets::Delegate)]
  ref class Attr : public Attribute {};
  
  [Attr] delegate void Test();
  [delegate:Attr] delegate void Test2();
  

• ReturnValue

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

Atribut obvykle přímo předchází elementu jazyka, na který se vztahuje. V některých případech však pozice atributu nestačí k určení zamýšleného cíle atributu. Podívejte se na tento příklad:

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

Syntakticky neexistuje způsob, jak zjistit, jestli se má atribut použít pro metodu nebo na návratovou hodnotu metody (v tomto případě je výchozí hodnotou metody). V takových případech lze použít specifikátor použití atributu. Pokud například chcete, aby se atribut použil na vrácenou hodnotu, použijte returnvalue specifikátor následujícím způsobem:

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

Specifikátory použití atributů jsou vyžadovány v následujících situacích:

• Určení atributu na úrovni sestavení nebo modulu

• Chcete-li určit, že atribut se vztahuje na návratovou hodnotu metody, nikoli metodu:

  [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
  

• Chcete-li určit, že atribut se vztahuje na přístupové objekty vlastnosti, nikoli vlastnost:

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

• Chcete-li určit, že se atribut vztahuje na přístup události, nikoli událost:

  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
  }
  

Specifikátor použití atributu se vztahuje pouze na atribut, který bezprostředně následuje za ním; To je

[returnvalue:Attr1, Attr2]

liší se od

[returnvalue:Attr1, returnvalue:Attr2]

Příklad

Popis

Tato ukázka ukazuje, jak zadat více cílů.

Kód

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

Viz také

Uživatelsky definované atributy