Generische Delegaten (Visual C++)
Sie können generische Typparameter mit Delegaten verwenden.Weitere Informationen über Delegaten finden Sie unter. delegate (Komponentenerweiterungen für C++)
[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 Attributes.TYPE-PARAMETER-Bezeichner
Eine durch Trennzeichen getrennte Liste mit Bezeichnern für die Typparameter.type-parameter-constraints-clauses
Verwendet das Format an, die angegeben wird Einschränkungen für generische Typparameter (C++/CLI)BarrierefreiheitModifizierer (optional)
Zugriffsmodifizierer (z. B.Öffentlich, private).Ergebnistyp
Der Rückgabetyp des Delegaten.identifier
Der Name des Delegaten.FormalPARAMETERS (optional)
Die Parameterliste des Delegaten.
Beispiel
Der Delegattyp angegeben Parameter werden an der Stelle, an der ein Delegatobjekt erstellt wird.muss der Delegat und die Methode, die ihm zugeordnete die gleiche Signatur haben.Im Folgenden finden Sie ein Beispiel einer generischen Delegatdeklaration.
// generics_generic_delegate1.cpp
// compile with: /clr /c
generic < class ItemType>
delegate ItemType GenDelegate(ItemType p1, ItemType% p2);
Das folgende Beispiel zeigt das an
Sie können dasselbe Delegatobjekt mit unterschiedlichen konstruierten Typen nicht verwenden.Erstellen Sie verschiedene Delegat Objekte für verschiedene Typen.
Ein generischer Delegat kann mit einer generischen Methode zugeordnet sind.
Wenn eine generische Methode aufgerufen wird, ohne Typargumente angeben, 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 erneut, indem er auf die Methode MyMethod zugeordnet wird, die den Typparameter ItemTypeverwendet.Zwei Instanzen des Delegaten (eine ganze Zahl und ein 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);
}