Generische Delegaten (C++/CLI)

Sie können generische Typparameter mit Delegaten verwenden. Weitere Informationen über Delegaten finden Sie unter delegate (C++/CLI und C++/CX).

Syntax

[attributes]
generic < [class | typename] type-parameter-identifiers>
[type-parameter-constraints-clauses]
[accessibility-modifiers] delegate result-type identifier
([formal-parameters]);

Parameter

attributes
(Optional) Zusätzliche deklarative Informationen. Weitere Informationen zu Attributen und Attributklassen finden Sie unter „Attribute“.

type-parameter-identifier(s)
Durch Trennzeichen getrennte Liste von Bezeichnern für die Typparameter.

type-parameter-constraints-clauses
Nimmt die in Einschränkungen für generische Typparameter (C++/CLI) angegebene Form an.

accessibility-modifiers
(Optional) Modifizierer für Barrierefreiheit (z. B. public, private).

result-type
Der Rückgabetyp des Delegaten.

identifier
Der Name des Delegaten.

formal-parameters
(Optional) Die Parameterliste des Delegaten.

Beispiele

Die Delegattypparameter werden angegeben, wenn ein Delegatobjekt erstellt wird. Der Delegat und die zugeordnete Methode müssen dieselbe Signatur aufweisen. Im folgenden Beispiel wird ein generischer Delegat deklariert.

// generics_generic_delegate1.cpp
// compile with: /clr /c
generic <class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);

Das folgende Beispiel zeigt Folgendes:

• Sie können nicht das gleiche Delegatobjekt mit unterschiedlichen konstruierten Typen verwenden. Erstellen Sie verschiedene Delegatobjekte für verschiedene Typen.

• Ein generischer Delegat kann einer generischen Methode zugeordnet werden.

• Wenn eine generische Methode ohne Angabe von Typargumenten aufgerufen wird, versucht der Compiler, die Typargumente für den Aufruf abzuleiten.

// generics_generic_delegate2.cpp
// compile with: /clr
generic <class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);

generic <class ItemType>
ref struct MyGenClass {
   ItemType MyMethod(ItemType i, ItemType % j) {
      return ItemType();
   }
};

ref struct MyClass {
   generic <class ItemType>
   static ItemType MyStaticMethod(ItemType i, ItemType % j) {
      return ItemType();
   }
};

int main() {
   MyGenClass<int> ^ myObj1 = gcnew MyGenClass<int>();
   MyGenClass<double> ^ myObj2 = gcnew MyGenClass<double>();
   GenDelegate<int>^ myDelegate1 =
      gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);

   GenDelegate<double>^ myDelegate2 =
      gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);

   GenDelegate<int>^ myDelegate =
      gcnew GenDelegate<int>(&MyClass::MyStaticMethod<int>);
}

Das folgende Beispiel deklariert einen generischen Delegaten GenDelegate<ItemType> und instanziiert ihn dann, indem er der Methode MyMethod zugeordnet wird, die den Typparameter ItemType verwendet. Zwei Instanzen des Delegaten (Integer und Double) werden erstellt und aufgerufen.

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

// declare generic delegate
generic <typename ItemType>
delegate ItemType GenDelegate (ItemType p1, ItemType% p2);

// Declare a generic class:
generic <typename ItemType>
ref class MyGenClass {
public:
   ItemType MyMethod(ItemType p1, ItemType% p2) {
      p2 = p1;
      return p1;
    }
};

int main() {
   int i = 0, j = 0;
   double m = 0.0, n = 0.0;

   MyGenClass<int>^ myObj1 = gcnew MyGenClass<int>();
   MyGenClass<double>^ myObj2 = gcnew MyGenClass<double>();

   // Instantiate a delegate using int.
   GenDelegate<int>^ MyDelegate1 =
      gcnew GenDelegate<int>(myObj1, &MyGenClass<int>::MyMethod);

   // Invoke the integer delegate using MyMethod.
   i = MyDelegate1(123, j);

   Console::WriteLine(
      "Invoking the integer delegate: i = {0}, j = {1}", i, j);

   // Instantiate a delegate using double.
   GenDelegate<double>^ MyDelegate2 =
      gcnew GenDelegate<double>(myObj2, &MyGenClass<double>::MyMethod);

   // Invoke the integer delegate using MyMethod.
   m = MyDelegate2(0.123, n);

   Console::WriteLine(
      "Invoking the double delegate: m = {0}, n = {1}", m, n);
}

Invoking the integer delegate: i = 123, j = 123
Invoking the double delegate: m = 0.123, n = 0.123

Siehe auch

Generics