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

Vlastní atributy umožňují rozšířit metadat rozhraní, třídy nebo struktury, metody, parametr nebo výčet.

Všechny verze

Všechny verze podporují vlastní atributy.

Prostředí Windows Runtime

C + +/ CX atributy podporují pouze vlastnosti, ale není atribut konstruktory nebo metody.

Požadavky

Možnost kompilátoru:/ZW

Modul CLR (Common Language Runtime)

Vlastní atributy umožňují rozšířit metadat spravovaného prvku.Další informace naleznete v tématu Rozšíření metadat pomocí atributů.

Poznámky

Informace a syntaxe v tomto tématu je určena k nahrazení informací v atribut.

Definování typu a provedením lze definovat vlastní atribut Attribute základní třída pro typ a volitelně použití AttributeUsageAttribute atribut.

Například v aplikaci Microsoft Transaction Server (MTS) 1.0, chování k transakce synchronizace, Vyrovnávání zatížení a podobně byl zadán prostřednictvím vlastní identifikátory GUID pomocí vlastního atributu Distanční vložen do knihovny typů.Klient serveru MTS mohou tedy určit jeho vlastnosti čtením knihovny typů.V rozhraní.NET Framework analogový typ knihovny je metadat a analogový Distanční vlastního atributu je vlastní atributy.Knihovnu typů pro čtení je také analogická pomocí reflexe typů.

Další informace naleznete v tématu,

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

• Typy parametrů atributů (rozšíření komponent C++)

Informace o podepisování sestavení v aplikaci Visual C++, Silný název sestavení (podpis sestavení) (C + +/ CLI).

Požadavky

Možnost kompilátoru:/clr

Příklady

Příklad

Následující příklad ukazuje, jak definovat vlastní atribut.

// user_defined_attributes.cpp
// compile with: /clr /c
using namespace System;

[AttributeUsage(AttributeTargets::All)]
ref struct Attr : public Attribute {
   Attr(bool i){}
   Attr(){}
};

[Attr]
ref class MyClass {};

Příklad

Následující příklad ukazuje některé důležité funkce vlastní atributy.Například Tento příklad ukazuje společné použití vlastních atributů: vytvoření instance serveru, který lze plně popsat sám klientům.

// extending_metadata_b.cpp
// compile with: /clr
using namespace System;
using namespace System::Reflection;

public enum class Access { Read, Write, Execute };

// Defining the Job attribute:
[AttributeUsage(AttributeTargets::Class, AllowMultiple=true )]
public ref class Job : Attribute {
public:
   property int Priority {
      void set( int value ) { m_Priority = value; }
      int get() { return m_Priority; }
   }

   // You can overload constructors to specify Job attribute in different ways
   Job() { m_Access = Access::Read; }
   Job( Access a ) { m_Access = a; }
   Access m_Access;

protected:
   int m_Priority;
};

interface struct IService {
   void Run();
};

   // Using the Job attribute:
   // Here we specify that QueryService is to be read only with a priority of 2.
   // To prevent namespace collisions, all custom attributes implicitly 
   // end with "Attribute". 

[Job( Access::Read, Priority=2 )]
ref struct QueryService : public IService {
   virtual void Run() {}
};

// Because we said AllowMultiple=true, we can add multiple attributes 
[Job(Access::Read, Priority=1)]
[Job(Access::Write, Priority=3)]
ref struct StatsGenerator : public IService {
   virtual void Run( ) {}
};

int main() {
   IService ^ pIS;
   QueryService ^ pQS = gcnew QueryService;
   StatsGenerator ^ pSG = gcnew StatsGenerator;

   //  use QueryService
   pIS = safe_cast<IService ^>( pQS );

   // use StatsGenerator
   pIS = safe_cast<IService ^>( pSG );

   // Reflection
   MemberInfo ^ pMI = pIS->GetType();
   array <Object ^ > ^ pObjs = pMI->GetCustomAttributes(false);
   
   // We can now quickly and easily view custom attributes for an 
   // Object through Reflection */
   for( int i = 0; i < pObjs->Length; i++ ) {
      Console::Write("Service Priority = ");
      Console::WriteLine(static_cast<Job^>(pObjs[i])->Priority);
      Console::Write("Service Access = ");
      Console::WriteLine(static_cast<Job^>(pObjs[i])->m_Access);
   }
}

Výsledek

Příklad

Objekt ^ typ nahrazuje typ dat variant.Následující příklad definuje vlastní atribut, který přijímá pole objekt ^ jako parametry.

Argumenty atributu musí být konstanty kompilace; ve většině případů by měla konstanta literály.

Viz typeid (rozšíření komponent C++) informace, jak vrátit hodnotu System::Type z bloku vlastní atribut.

// extending_metadata_e.cpp
// compile with: /clr /c
using namespace System;
[AttributeUsage(AttributeTargets::Class | AttributeTargets::Method)]
public ref class AnotherAttr : public Attribute {
public:
   AnotherAttr(array<Object^>^) {}
   array<Object^>^ var1;
};

// applying the attribute
[ AnotherAttr( gcnew array<Object ^> { 3.14159, "pi" }, var1 = gcnew array<Object ^> { "a", "b" } ) ]
public ref class SomeClass {};

Příklad

Modul runtime vyžaduje, že veřejné části třídu vlastního atributu musí být serializovatelné.Při vytváření vlastních atributů, jsou omezeny na konstanty kompilace pojmenované argumenty vlastní atribut.(Jej představit jako posloupnost bitů, které jsou připojeny k rozložení třídy v metadatech.)

// extending_metadata_f.cpp
// compile with: /clr /c
using namespace System;
ref struct abc {};

[AttributeUsage( AttributeTargets::All )]
ref struct A : Attribute {
   A( Type^ ) {}
   A( String ^ ) {}
   A( int ) {}
};

[A( abc::typeid )]
ref struct B {};

Viz také

Koncepty

Součást rozšíření pro Runtime platformy