Procedura: definire e utilizzare delegati (C++/CLI)

Articolo
10/12/2023

Questo articolo illustra come definire e usare delegati in C++/CLI.

Anche se .NET Framework fornisce un certo numero di delegati, a volte potrebbe essere necessario definire nuovi delegati.

Nell'esempio di codice seguente viene definito un delegato denominato MyCallback. Il codice di gestione degli eventi, ovvero la funzione chiamata quando viene generato questo nuovo delegato, deve avere un tipo restituito e void accettare un String riferimento.

La funzione main usa un metodo statico definito da SomeClass per creare un'istanza del MyCallback delegato. Il delegato diventa quindi un metodo alternativo per chiamare questa funzione, come illustrato inviando la stringa "single" all'oggetto delegato. Successivamente, le istanze aggiuntive di MyCallback vengono collegate insieme e quindi eseguite da una chiamata all'oggetto delegato.

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

ref class SomeClass
{
public:
   static void Func(String^ str)
   {
      Console::WriteLine("static SomeClass::Func - {0}", str);
   }
};

ref class OtherClass
{
public:
   OtherClass( Int32 n )
   {
      num = n;
   }

   void Method(String^ str)
   {
      Console::WriteLine("OtherClass::Method - {0}, num = {1}",
         str, num);
   }

   Int32 num;
};

delegate void MyCallback(String^ str);

int main( )
{
   MyCallback^ callback = gcnew MyCallback(SomeClass::Func);
   callback("single");

   callback += gcnew MyCallback(SomeClass::Func);

   OtherClass^ f = gcnew OtherClass(99);
   callback += gcnew MyCallback(f, &OtherClass::Method);

   f = gcnew OtherClass(100);
   callback += gcnew MyCallback(f, &OtherClass::Method);

   callback("chained");

   return 0;
}

static SomeClass::Func - single
static SomeClass::Func - chained
static SomeClass::Func - chained
OtherClass::Method - chained, num = 99
OtherClass::Method - chained, num = 100

Nell'esempio di codice successivo viene illustrato come associare un delegato a un membro di una classe valore.

// mcppv2_del_mem_value_class.cpp
// compile with: /clr
using namespace System;
public delegate void MyDel();

value class A {
public:
   void func1() {
      Console::WriteLine("test");
   }
};

int main() {
   A a;
   A^ ah = a;
   MyDel^ f = gcnew MyDel(a, &A::func1);   // implicit box of a
   f();
   MyDel^ f2 = gcnew MyDel(ah, &A::func1);
   f2();
}

test
test

Come comporre delegati

È possibile usare l'operatore "-" per rimuovere un delegato di componente da un delegato composto.

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

delegate void MyDelegate(String ^ s);

ref class MyClass {
public:
   static void Hello(String ^ s) {
      Console::WriteLine("Hello, {0}!", s);
   }

   static void Goodbye(String ^ s) {
      Console::WriteLine("  Goodbye, {0}!", s);
   }
};

int main() {

   MyDelegate ^ a = gcnew MyDelegate(MyClass::Hello);
   MyDelegate ^ b = gcnew MyDelegate(MyClass::Goodbye);
   MyDelegate ^ c = a + b;
   MyDelegate ^ d = c - a;

   Console::WriteLine("Invoking delegate a:");
   a("A");
   Console::WriteLine("Invoking delegate b:");
   b("B");
   Console::WriteLine("Invoking delegate c:");
   c("C");
   Console::WriteLine("Invoking delegate d:");
   d("D");
}

Output

Invoking delegate a:
Hello, A!
Invoking delegate b:
  Goodbye, B!
Invoking delegate c:
Hello, C!
  Goodbye, C!
Invoking delegate d:
  Goodbye, D!

Passare un delegato^ a una funzione nativa che prevede un puntatore a funzione

Da un componente gestito è possibile chiamare una funzione nativa con parametri puntatore a funzione in cui la funzione nativa può quindi chiamare la funzione membro del delegato del componente gestito.

Questo esempio crea la dll che esporta la funzione nativa:

// delegate_to_native_function.cpp
// compile with: /LD
#include < windows.h >
extern "C" {
   __declspec(dllexport)
   void nativeFunction(void (CALLBACK *mgdFunc)(const char* str)) {
      mgdFunc("Call to Managed Function");
   }
}

L'esempio successivo usa il file DLL e passa un handle delegato alla funzione nativa che prevede un puntatore a funzione.

// delegate_to_native_function_2.cpp
// compile with: /clr
using namespace System;
using namespace System::Runtime::InteropServices;

delegate void Del(String ^s);
public ref class A {
public:
   void delMember(String ^s) {
      Console::WriteLine(s);
   }
};

[DllImportAttribute("delegate_to_native_function", CharSet=CharSet::Ansi)]
extern "C" void nativeFunction(Del ^d);

int main() {
   A ^a = gcnew A;
   Del ^d = gcnew Del(a, &A::delMember);
   nativeFunction(d);   // Call to native function
}

Output

Call to Managed Function

Per associare delegati a funzioni non gestite

Per associare un delegato a una funzione nativa, è necessario eseguire il wrapping della funzione nativa in un tipo gestito e dichiarare la funzione da richiamare tramite PInvoke.

// mcppv2_del_to_umnangd_func.cpp
// compile with: /clr
#pragma unmanaged
extern "C" void printf(const char*, ...);
class A {
public:
   static void func(char* s) {
      printf(s);
   }
};

#pragma managed
public delegate void func(char*);

ref class B {
   A* ap;

public:
   B(A* ap):ap(ap) {}
   void func(char* s) {
      ap->func(s);
   }
};

int main() {
   A* a = new A;
   B^ b = gcnew B(a);
   func^ f = gcnew func(b, &B::func);
   f("hello");
   delete a;
}

Output

hello

Per usare delegati non associati

È possibile usare un delegato non associato per passare un'istanza del tipo di cui si desidera chiamare la funzione quando viene chiamato il delegato.

I delegati non associati sono particolarmente utili se si vuole scorrere gli oggetti in una raccolta, usando per ogni parola chiave in e chiamare una funzione membro in ogni istanza.

Ecco come dichiarare, creare un'istanza e chiamare delegati associati e non associati:

Azione	Delegati associati	Delegati non associati
Declare	La firma del delegato deve corrispondere alla firma della funzione che si vuole chiamare tramite il delegato.	Il primo parametro della firma del delegato è il tipo di `this` per l'oggetto che si desidera chiamare. Dopo il primo parametro, la firma del delegato deve corrispondere alla firma della funzione che si vuole chiamare tramite il delegato.
Crea un'istanza per	Quando si crea un'istanza di un delegato associato, è possibile specificare una funzione di istanza o una funzione membro globale o statica. Per specificare una funzione di istanza, il primo parametro è un'istanza del tipo la cui funzione membro si desidera chiamare e il secondo parametro è l'indirizzo della funzione che si desidera chiamare. Se si desidera chiamare una funzione membro globale o statica, è sufficiente passare il nome di una funzione globale o il nome della funzione membro statica.	Quando si crea un'istanza di un delegato non associato, è sufficiente passare l'indirizzo della funzione che si vuole chiamare.
Chiama	Quando si chiama un delegato associato, è sufficiente passare i parametri richiesti dalla firma del delegato.	Uguale a un delegato associato, ma tenere presente che il primo parametro deve essere un'istanza dell'oggetto che contiene la funzione che si desidera chiamare.

Questo esempio illustra come dichiarare, creare un'istanza e chiamare delegati non associati:

// unbound_delegates.cpp
// compile with: /clr
ref struct A {
   A(){}
   A(int i) : m_i(i) {}
   void Print(int i) { System::Console::WriteLine(m_i + i);}

private:
   int m_i;
};

value struct V {
   void Print() { System::Console::WriteLine(m_i);}
   int m_i;
};

delegate void Delegate1(A^, int i);
delegate void Delegate2(A%, int i);

delegate void Delegate3(interior_ptr<V>);
delegate void Delegate4(V%);

delegate void Delegate5(int i);
delegate void Delegate6();

int main() {
   A^ a1 = gcnew A(1);
   A% a2 = *gcnew A(2);

   Delegate1 ^ Unbound_Delegate1 = gcnew Delegate1(&A::Print);
   // delegate takes a handle
   Unbound_Delegate1(a1, 1);
   Unbound_Delegate1(%a2, 1);

   Delegate2 ^ Unbound_Delegate2 = gcnew Delegate2(&A::Print);
   // delegate takes a tracking reference (must deference the handle)
   Unbound_Delegate2(*a1, 1);
   Unbound_Delegate2(a2, 1);

   // instantiate a bound delegate to an instance member function
   Delegate5 ^ Bound_Del = gcnew Delegate5(a1, &A::Print);
   Bound_Del(1);

   // instantiate value types
   V v1 = {7};
   V v2 = {8};

   Delegate3 ^ Unbound_Delegate3 = gcnew Delegate3(&V::Print);
   Unbound_Delegate3(&v1);
   Unbound_Delegate3(&v2);

   Delegate4 ^ Unbound_Delegate4 = gcnew Delegate4(&V::Print);
   Unbound_Delegate4(v1);
   Unbound_Delegate4(v2);

   Delegate6 ^ Bound_Delegate3 = gcnew Delegate6(v1, &V::Print);
   Bound_Delegate3();
}

Output

Nell'esempio seguente viene illustrato come usare delegati non associati e per ognuno, nelle parole chiave per scorrere gli oggetti in una raccolta e chiamare una funzione membro in ogni istanza.

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

ref class RefClass {
   String^ _Str;

public:
   RefClass( String^ str ) : _Str( str ) {}
   void Print() { Console::Write( _Str ); }
};

delegate void PrintDelegate( RefClass^ );

int main() {
   PrintDelegate^ d = gcnew PrintDelegate( &RefClass::Print );

   array< RefClass^ >^ a = gcnew array<RefClass^>( 10 );

   for ( int i = 0; i < a->Length; ++i )
      a[i] = gcnew RefClass( i.ToString() );

   for each ( RefClass^ R in a )
      d( R );

   Console::WriteLine();
}

Questo esempio crea un delegato non associato alle funzioni di accesso di una proprietà:

// unbound_delegates_3.cpp
// compile with: /clr
ref struct B {
   property int P1 {
      int get() { return m_i; }
      void set(int i) { m_i = i; }
   }

private:
   int m_i;
};

delegate void DelBSet(B^, int);
delegate int DelBGet(B^);

int main() {
   B^ b = gcnew B;

   DelBSet^ delBSet = gcnew DelBSet(&B::P1::set);
   delBSet(b, 11);

   DelBGet^ delBGet = gcnew DelBGet(&B::P1::get);
   System::Console::WriteLine(delBGet(b));
}

Output

L'esempio seguente illustra come richiamare un delegato multicast, in cui un'istanza è associata e un'istanza non è associata.

// unbound_delegates_4.cpp
// compile with: /clr
ref class R {
public:
   R(int i) : m_i(i) {}

   void f(R ^ r) {
      System::Console::WriteLine("in f(R ^ r)");
   }

   void f() {
      System::Console::WriteLine("in f()");
   }

private:
   int m_i;
};

delegate void Del(R ^);

int main() {
   R ^r1 = gcnew R(11);
   R ^r2 = gcnew R(12);

   Del^ d = gcnew Del(r1, &R::f);
   d += gcnew Del(&R::f);
   d(r2);
};

Output

in f(R ^ r)
in f()

L'esempio seguente illustra come creare e chiamare un delegato generico non associato.

// unbound_delegates_5.cpp
// compile with: /clr
ref struct R {
   R(int i) : m_i(i) {}

   int f(R ^) { return 999; }
   int f() { return m_i + 5; }

   int m_i;
};

value struct V {
   int f(V%) { return 999; }
   int f() { return m_i + 5; }

   int m_i;
};

generic <typename T>
delegate int Del(T t);

generic <typename T>
delegate int DelV(T% t);

int main() {
   R^ hr = gcnew R(7);
   System::Console::WriteLine((gcnew Del<R^>(&R::f))(hr));

   V v;
   v.m_i = 9;
   System::Console::WriteLine((gcnew DelV<V >(&V::f))(v) );
}

Output

12
14

Vedi anche

delegate (estensioni del componente C++)

Procedura: definire e utilizzare delegati (C++/CLI)

Come comporre delegati

Passare un delegato^ a una funzione nativa che prevede un puntatore a funzione

Per associare delegati a funzioni non gestite

Per usare delegati non associati

Vedi anche

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive