Sdílet prostřednictvím

Cíle atributů (rozšíření komponent C++)

  • Článek

Atribut použití specifikátorů umožňují určit atribut cíle. Každý atribut je definován pro určité prvky jazyka.Například atribut mohou být definovány pouze pro třídy a struktur. Následující seznam obsahuje možné syntaktické prvky, na kterých lze použít vlastní atribut.Kombinace těchto hodnot (pomocí logické nebo) mohou být použity.

Chcete-li určit cílový atribut k předání jednoho nebo více AttributeTargets enumerátory k AttributeUsageAttribute při definování atributu.

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

Cíl

Příklad použití

Všechna

(platí pro všechny konstrukce)

 
// attribute_targets_all.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::All)]
ref class Attr : public Attribute {};
[assembly:Attr];

Assembly

(platí pro sestavení jako celku)

 
// attribute_targets_assembly.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Assembly)]
ref class Attr : public Attribute {};
[assembly:Attr];

Modul

(platí pro modul jako celku)

 
// attribute_targets_module.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Module)]
ref class Attr : public Attribute {};
[module:Attr];

Třída

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

výčet

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

Property

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

Událost

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

Rozhraní

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

Delegovat

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

Atribut obvykle přímo předchází prvek jazyka, na které se vztahuje.V některých případech však umístění atributu nestačí k určení zamýšleného cíle na atribut.Vezměme si jako příklad:

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

Syntakticky, neexistuje žádný způsob, jak zjistit, pokud je určen atribut použít metodu nebo metody vrácenou hodnotu (v tomto případě bude výchozí metodu).V takových případech mohou být použity použití specifikátor atributu.Například atribut použít hodnotu vrácenou pomocí returnvalue specifikátor následujícím způsobem:

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

Atribut použití specifikátory jsou nutné v následujících situacích:

  • Chcete-li určit atribut úrovně sestavení nebo modul.

  • Chcete-li určit, že atribut použije pro vrácenou hodnotu metody není 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

  • Chcete-li určit, že atribut použije pro přistupující vlastnosti není 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 atribut se vztahuje na události přistupujícího objektu, 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
}

Použití specifikátor atributu platí pouze pro atribut, který následuje. To znamená,

[returnvalue:Attr1, Attr2]

se liší od

[returnvalue:Attr1, returnvalue:Attr2]

Příklad

Description

Tento příklad ukazuje, jak zadat více cílů.

Kód

// attribute_targets.cpp
// compile with: /clr /c
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é

Referenční dokumentace

Uživatelsky definované atributy (rozšíření komponent C++)