Miejsca docelowe atrybutu (C++/CLI i C++/CX)

Specyfikatory użycia atrybutów umożliwiają określenie obiektów docelowych atrybutów. Każdy atrybut jest definiowany w celu zastosowania do niektórych elementów języka. Na przykład atrybut może być zdefiniowany w celu zastosowania tylko do klas i struktur. Na poniższej liście przedstawiono możliwe elementy składniowe, na których można użyć atrybutu niestandardowego. Mogą być używane kombinacje tych wartości (przy użyciu wartości logicznych lub).

Aby określić element docelowy atrybutu, należy przekazać co najmniej jeden AttributeTargets moduł wyliczający podczas AttributeUsageAttribute definiowania atrybutu.

Poniżej znajduje się lista prawidłowych elementów docelowych atrybutów:

• All (dotyczy wszystkich konstrukcji)

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

• Assembly (dotyczy zestawu jako całości)

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

• Module (dotyczy modułu jako całości)

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

Zazwyczaj atrybut bezpośrednio poprzedza element języka, do którego ma zastosowanie. W niektórych przypadkach jednak pozycja atrybutu nie jest wystarczająca do określenia zamierzonego obiektu docelowego atrybutu. Rozważ taki przykład:

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

Składniowo nie ma sposobu, aby stwierdzić, czy atrybut ma być stosowany do metody lub do wartości zwracanej metody (w tym przypadku domyślnie jest to metoda). W takich przypadkach można użyć specyfikatora użycia atrybutów. Aby na przykład zastosować atrybut do wartości zwracanej, użyj specyfikatora returnvalue w następujący sposób:

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

Specyfikatory użycia atrybutów są wymagane w następujących sytuacjach:

• Aby określić atrybut na poziomie zestawu lub modułu.

• Aby określić, że atrybut ma zastosowanie do wartości zwracanej metody, a nie metody:

  [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 ma zastosowanie do metody dostępu właściwości, a nie właściwości:

  [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 ma zastosowanie do metody dostępu zdarzenia, a nie zdarzenia:

  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
  }
  

Specyfikator użycia atrybutu ma zastosowanie tylko do atrybutu, który natychmiast następuje po nim; Czyli

[returnvalue:Attr1, Attr2]

różni się od

[returnvalue:Attr1, returnvalue:Attr2]

Przykład

opis

W tym przykładzie pokazano, jak określić wiele obiektów docelowych.

Kod

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

Zobacz też

Atrybuty zdefiniowane przez użytkownika