Uživatelsky definované atributy (rozšíření komponent C++)
Vlastní atributy umožňují rozšířit rozhraní, třídy nebo struktury, metody, parametr, nebo výčet metadat.
Všechny moduly runtime
Všechny Runtimes nepodporuje vlastní atributy.
Prostředí Windows Runtime
C + +/ podporují pouze vlastnosti atributy CX, ale nikoli atribut konstruktory a metody.
Požadavky
Možnost kompilátoru: /ZW
Common Language Runtime
Vlastní atributy umožňují rozšíření spravovaný systémový prvek metadat.Další informace naleznete v tématu Rozšiřování metadat pomocí atributů.
Poznámky
Informace a syntaxe v tomto tématu je určena k nahrazení informace zobrazené v – atribut.
Můžete definovat vlastní atribut tak, že definování typu a Attribute základní třída pro typ a volitelně použití AttributeUsageAttribute atribut.
Například v aplikaci Microsoft Transaction Server (MTS) verze 1.0, chování, pokud jde o 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í vkládány do knihovny typů.Proto klientské aplikace serveru MTS mohou určit jeho vlastnosti čtením knihovny typů.V rozhraní.NET Framework je analogový knihovny typů metadat a analogový Distanční vlastního atributu je vlastní atributy.Knihovnu typů pro čtení je také podobných typů pomocí reflexe.
Další informace naleznete v tématu:
Informace o podepisování sestavení v aplikaci Visual C++ naleznete v tématu Sestavení se silným názvem (Podepisování 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.V tomto příkladu příkladem běžného použití vlastních atributů: vytvoření instance serveru, který lze plně popsat sám sebe 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 objektu ^ jako parametry.
Argumenty atributu musí být konstanty kompilace; ve většině případů musí být konstanta literály.
Viz typeid (rozšíření komponent C++) informace o vrácení hodnoty System::Type z bloku vlastního atributu.
// 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, aby veřejné část třídy vlastní atribut musí být serializovatelné. Při vytváření vlastních atributů, jsou omezeny na kompilační konstanty pojmenované argumenty vlastní atribut. (Si 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 {};