Target Atribut (C++/CLI dan C++/CX)

Penentu penggunaan atribut memungkinkan Anda menentukan target atribut. Setiap atribut didefinisikan untuk diterapkan ke elemen bahasa tertentu. Misalnya, atribut mungkin didefinisikan untuk diterapkan hanya ke kelas dan struktur. Daftar berikut menunjukkan kemungkinan elemen syntactic tempat atribut kustom dapat digunakan. Kombinasi nilai-nilai ini (menggunakan logis atau) dapat digunakan.

Untuk menentukan target atribut, untuk meneruskan satu atau beberapa AttributeTargets enumerator AttributeUsageAttribute saat menentukan atribut.

Berikut ini adalah daftar target atribut yang valid:

• All (berlaku untuk semua konstruksi)

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

• Assembly (berlaku untuk rakitan secara keseluruhan)

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

• Module (berlaku untuk modul secara keseluruhan)

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

Biasanya, atribut secara langsung mendahului elemen bahasa yang diterapkannya. Namun, dalam beberapa kasus, posisi atribut tidak cukup untuk menentukan target atribut yang dimaksudkan. Pertimbangkan contoh ini:

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

Secara sintis, tidak ada cara untuk mengetahui apakah atribut dimaksudkan untuk diterapkan ke metode atau ke nilai pengembalian metode (dalam hal ini, atribut default ke metode ). Dalam kasus seperti itu, penentu penggunaan atribut dapat digunakan. Misalnya, untuk membuat atribut berlaku untuk nilai pengembalian, gunakan penentu returnvalue , sebagai berikut:

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

Penentu penggunaan atribut diperlukan dalam situasi berikut:

• Untuk menentukan atribut tingkat rakitan atau modul.

• Untuk menentukan bahwa atribut berlaku untuk nilai pengembalian metode, bukan metode :

  [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
  

• Untuk menentukan bahwa atribut berlaku untuk aksesor properti, bukan properti :

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

• Untuk menentukan bahwa atribut berlaku untuk aksesor peristiwa, bukan peristiwa:

  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
  }
  

Penentu penggunaan atribut hanya berlaku untuk atribut yang segera mengikutinya; Yaitu

[returnvalue:Attr1, Attr2]

berbeda dari

[returnvalue:Attr1, returnvalue:Attr2]

Contoh

Deskripsi

Sampel ini menunjukkan cara menentukan beberapa target.

Kode

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

Lihat juga

Atribut yang Ditentukan Pengguna