Öznitelik Hedefleri (C++/CLI ve C++/CX)

Öznitelik kullanımı tanımlayıcıları, öznitelik hedeflerini belirtmenize olanak tanır. Her öznitelik, belirli dil öğelerine uygulanacak şekilde tanımlanır. Örneğin, bir öznitelik yalnızca sınıflara ve yapılara uygulanacak şekilde tanımlanabilir. Aşağıdaki listede, özel bir özniteliğin kullanılabilmesi için olası sağlam öğeler gösterilmektedir. Bu değerlerin birleşimleri (mantıksal veya kullanılarak) kullanılabilir.

Öznitelik hedefini belirtmek için, özniteliği tanımlarken bir veya daha fazla AttributeTargets numaralandırıcı geçirmek için AttributeUsageAttribute .

Geçerli öznitelik hedeflerinin listesi aşağıdadır:

• All (tüm yapılar için geçerlidir)

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

• Assembly (bütün olarak bir derleme için geçerlidir)

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

• Module (bir modülün tamamı için geçerlidir)

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

Genellikle, bir öznitelik doğrudan uygulandığı dil öğesinden öncedir. Ancak bazı durumlarda özniteliğin konumu, özniteliğin hedeflenen hedefini belirlemek için yeterli değildir. Bu örneği ele alalım:

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

Söz dizimsel olarak, özniteliğin yönteme mi yoksa yöntemin dönüş değerine mi uygulanacağını anlamanın bir yolu yoktur (bu durumda, varsayılan olarak yöntemidir). Böyle durumlarda, bir öznitelik kullanım tanımlayıcısı kullanılabilir. Örneğin, özniteliğin dönüş değerine uygulanmasını sağlamak için tanımlayıcıyı returnvalue aşağıdaki gibi kullanın:

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

Öznitelik kullanım tanımlayıcıları aşağıdaki durumlarda gereklidir:

• Derleme veya modül düzeyi özniteliği belirtmek için.

• Özniteliğin yönteme değil yöntemin dönüş değerine uygulanacağını belirtmek için:

  [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
  

• Özniteliğin özelliğine değil özelliğin erişimcisine uygulanacağını belirtmek için:

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

• Özniteliğin olay için değil olayın erişimcisine uygulanacağını belirtmek için:

  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
  }
  

Öznitelik kullanım belirticisi yalnızca hemen izleyen özniteliğe uygulanır; Yani

[returnvalue:Attr1, Attr2]

şundan farklıdır:

[returnvalue:Attr1, returnvalue:Attr2]

Örnek

Açıklama

Bu örnek, birden çok hedefin nasıl belirtileceğini gösterir.

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

Ayrıca bkz.

Kullanıcı Tanımlı Öznitelikler