Atrybuty zdefiniowane przez użytkownika (C++ Component Extensions)

Atrybuty niestandardowe umożliwiają rozszerzenie metadane interfejsu, klasy lub struktury, metoda, parametru lub wyliczenia.

Wszystkie środowiska wykonawcze

Wszystkie programy obsługi obsługuje atrybutów niestandardowych.

Środowisko wykonawcze systemu Windows

C + +/ CX atrybuty obsługują tylko właściwości, ale nie atrybut konstruktorów lub metod.

Wymagania

Opcja kompilatora: /ZW

Środowisko uruchomieniowe języka wspólnego

Atrybuty niestandardowe umożliwiają rozszerzenie metadanych zarządzany element.Aby uzyskać więcej informacji, zobacz Rozszerzanie metadanych za pomocą atrybutów.

Uwagi

Informacje i przedstawione w tym temacie składni ma na celu zastąpienia informacje przedstawione w — atrybut.

Zdefiniowanie typu i dokonując można zdefiniować niestandardowy atrybut Attribute klasą bazową dla typu i opcjonalnie stosowanie AttributeUsageAttribute atrybut.

Na przykład in Microsoft Transaction Server (MTS) 1.0, zachowanie w odniesieniu do transakcji, synchronizacja, równoważenie obciążenia, i tak dalej został określony za pomocą niestandardowych identyfikatorów GUID wstawione do biblioteki typów, używając atrybutu niestandardowego ODL.W związku z tym klient serwera MTS może określić jego właściwości czytając biblioteki typów.W.NET Framework analogowe biblioteki typów są metadane i analogowe niestandardowy atrybut ODL jest atrybutów niestandardowych.Ponadto czytanie biblioteki typów jest analogiczne do typów przy użyciu odbicia.

Aby uzyskać więcej informacji zobacz temat,

• Docelowe atrybuty (C++ Component Extensions)

• Typy parametrów atrybutu (C++ Component Extensions)

Aby uzyskać informacje dotyczące podpisywania zestawów w programie Visual C++, zobacz Zestawy o silnych nazwach (podpisywanie zestawów) (C++/CLI).

Wymagania

Opcja kompilatora: /clr

Przykłady

Przykład

Poniższy przykład pokazuje sposób definiowania atrybutu niestandardowego.

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

Przykład

Poniższy przykład ilustruje niektóre ważne funkcje niestandardowe atrybuty.Na przykład, w tym przykładzie przedstawiono wspólnego użytkowania atrybuty niestandardowe: utworzenie wystąpienia serwera, na którym pełni można opisywać sam do klientów.

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

Dane wyjściowe

Przykład

Obiekt ^ typ zastąpi typ danych variant.W poniższym przykładzie zdefiniowano niestandardowy atrybut, który pobiera tablicę obiektów ^ jako parametry.

Atrybut argumenty muszą być stałymi znanymi w czasie kompilacji; w większości przypadków powinny one być stała literały.

Zobacz typeid (C++ Component Extensions) informacji na temat sposobu zwracania wartości System::Type z bloku atrybutu niestandardowego.

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

Przykład

Środowisko czasu wykonania wymaga, że część publiczna niestandardowa klasa atrybutów musi być możliwy do serializacji. Podczas tworzenia niestandardowych atrybutów, nazwanych argumentów niestandardowy atrybut są ograniczone do wartości stałych podczas kompilacji. (Go traktować jako sekwencję bitów, dołączane do układu klasy metadanych.)

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

Zobacz też

Koncepcje

Component Extensions dla platform środowiska uruchomieniowego