delegate (C++/CLI und C++/CX)

  • Artikel

Deklariert einen Typ, der einen Funktionszeiger repräsentiert.

Alle Laufzeiten

Sowohl Windows-Runtime als auch Common Language Runtime unterstützen Delegaten.

Hinweise

delegate ist ein kontextbezogenes Schlüsselwort. Weitere Informationen finden Sie unter Kontextbezogene Schlüsselwörter.

Um zur Kompilierzeit zu ermitteln, ob ein Typ ein Delegat ist, verwenden Sie das Typmerkmal __is_delegate(). Weitere Informationen finden Sie unter Compilerunterstützung für Typmerkmale.

Windows-Runtime

C++/CX unterstützt Delegaten mit der folgenden Syntax.

Syntax

access
delegate
return-type
delegate-type-identifier
(
[ parameters ]
)

Parameter

access
(optional) Die Barrierefreiheit der Stellvertretung, die public (Standard) oder private. Der Funktionsprototyp kann auch mit den const oder volatile Schlüsselwort (keyword) qualifiziert werden.

return-type
Der Rückgabetyp des Funktionsprototyps.

delegate-type-identifier
Der Name des deklarierten Delegattyps.

parameters
(Optional) Die Typen und Bezeichner des Funktionsprototyps.

Hinweise

Verwenden Sie den delegate-type-identifier, um ein Ereignis mit dem gleichen Prototypen wie der Delegat zu deklarieren. Weitere Informationen finden Sie unter Delegaten (C++/CX).

Anforderungen

Compileroption: /ZW

Übersicht: Common Language Runtime (CLR)

Die Common Language Runtime unterstützt Delegaten mit der folgenden Syntax.

Syntax

access
delegate
function_declaration

Parameter

access
(Optional) Der Zugriff auf den Delegaten außerhalb der Assembly kann „public“ oder „private“ lauten. Der Standardwert ist „private“. Innerhalb einer Klasse kann ein Delegat einen beliebigen Zugriff aufweisen.

function_declaration
Die Signatur der Funktion, die an den Delegaten gebunden werden kann. Der Rückgabetyp eines Delegaten kann jeder verwaltete Typ sein. Aus Gründen der Interoperabilität empfiehlt es sich, dass der Rückgabetyp eines Delegaten ein CLS-Typ ist.

Zum Definieren eines ungebundenen Delegaten sollte der erste Parameter in function_declaration der Typ des this Zeigers für das Objekt sein.

Hinweise

Delegaten unterstützen eine mehrfache Umwandlung: Der Funktionszeiger kann an eine oder mehrere Methoden innerhalb einer verwalteten Klasse gebunden sein. Das Schlüsselwort delegate definiert einen Multicastdelegattypen mit einer bestimmten Methodensignatur.

Ein Delegat kann auch an die Methode einer Wertklasse gebunden sein, wie beispielsweise im Fall einer statischen Methode.

Ein Delegat weist die folgenden Merkmale auf:

  • Er erbt von System::MulticastDelegate.

  • Er verfügt über einen Konstruktor, der zwei Argumente akzeptiert: einen Zeiger auf eine verwaltete Klasse oder NULL (im Fall der Bindung an eine statische Methode) und eine vollständig qualifizierte Methode des angegebenen Typs.

  • Er verfügt über eine Methode mit dem Namen Invoke, deren Signatur der deklarierten Signatur des Delegaten entspricht.

Wenn ein Delegat aufgerufen wird, werden die entsprechenden Funktionen in der Reihenfolge aufgerufen, in der sie angefügt wurden.

Der Rückgabewert eines Delegaten ist der Rückgabewert aus der letzten angefügten Memberfunktion.

Delegaten können nicht überladen werden.

Delegaten können gebunden oder nicht gebunden sein.

Wenn Sie einen gebundenen Delegaten instanziieren, muss das erste Argument ein Objektverweis sein. Das zweite Argument einer Delegatinstanziierung muss entweder die Adresse einer Methode eines verwalteten Klassenobjekts oder ein Zeiger auf eine Methode eines Werttyps sein. Das zweite Argument einer Delegatinstanziierung muss die Methode mit der vollständigen Syntax im Gültigkeitsbereich der Klasse benennen und den address-of-Operator anwenden.

Wenn Sie einen nicht gebundenen Delegaten instanziieren, muss das zweite Argument entweder die Adresse einer Methode eines verwalteten Klassenobjekts oder ein Zeiger auf eine Methode eines Werttyps sein. Das Argument muss die Methode mit der vollständigen Syntax im Gültigkeitsbereich der Klasse benennen und den address-of-Operator anwenden.

Beim Erstellen eines Delegaten für eine statische oder globale Funktion ist nur ein Parameter erforderlich: die Funktion (optional die Adresse der Funktion).

Weitere Informationen über Delegaten finden Sie unter folgenden Links:

Anforderungen

Compileroption: /clr

Beispiele

Das folgende Beispiel zeigt, wie Sie Delegaten deklarieren, initialisieren und aufrufen.

// mcppv2_delegate.cpp
// compile with: /clr
using namespace System;

// declare a delegate
public delegate void MyDel(int i);

ref class A {
public:
   void func1(int i) {
      Console::WriteLine("in func1 {0}", i);
   }

   void func2(int i) {
      Console::WriteLine("in func2 {0}", i);
   }

   static void func3(int i) {
      Console::WriteLine("in static func3 {0}", i);
   }
};

int main () {
   A ^ a = gcnew A;

   // declare a delegate instance
   MyDel^ DelInst;

   // test if delegate is initialized
   if (DelInst)
      DelInst(7);

   // assigning to delegate
   DelInst = gcnew MyDel(a, &A::func1);

   // invoke delegate
   if (DelInst)
      DelInst(8);

   // add a function
   DelInst += gcnew MyDel(a, &A::func2);

   DelInst(9);

   // remove a function
   DelInst -= gcnew MyDel(a, &A::func1);

   // invoke delegate with Invoke
   DelInst->Invoke(10);

   // make delegate to static function
   MyDel ^ StaticDelInst = gcnew MyDel(&A::func3);
   StaticDelInst(11);
}

in func1 8

in func1 9

in func2 9

in func2 10

in static func3 11

Siehe auch

Komponentenerweiterungen für .NET und UWP