Como definir e usar delegados (C++/CLI)

Artigo
10/12/2023

Este artigo mostra como definir e consumir delegados em C++/CLI.

Embora o .NET Framework forneça vários delegados, às vezes você pode ter que definir novos delegados.

O exemplo de código a seguir define um delegado chamado MyCallback. O código de tratamento de eventos — a função que é chamada quando esse novo delegado é acionado — deve ter um tipo de retorno de void e fazer uma referência a String.

A função principal usa um método estático definido por SomeClass para instanciar o delegado MyCallback. Em seguida, o delegado se torna um método alternativo de chamar essa função, conforme demonstrado ao enviar a cadeia de caracteres "single" para o objeto delegado. Em seguida, instâncias adicionais de MyCallback são vinculadas e executadas por uma chamada ao objeto delegado.

// 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

O exemplo de código a seguir mostra como associar um delegado a um membro de uma classe de valor.

// 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

Como compor delegados

Você pode usar o operador "-" para remover um delegado de componente de um delegado 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");
}

Saída

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

Transmita um delegado^ para uma função nativa que aguarda um ponteiro de função

Em um componente gerenciado, você pode chamar uma função nativa com parâmetros de ponteiro de função em que a função nativa pode chamar a função membro do delegado do componente gerenciado.

Este exemplo cria o .dll que exporta a função 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");
   }
}

O exemplo seguinte consome o .dll e passa um identificador de delegado para a função nativa que espera um ponteiro de função.

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

Saída

Call to Managed Function

Para associar delegados a funções não gerenciadas

Para associar um delegado a uma função nativa, você deve encapsular a função nativa em um tipo gerenciado e declarar a função a ser invocada por meio de 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;
}

Saída

hello

Para usar delegados não associados

Você pode usar um delegado não associado para passar uma instância do tipo cuja função você deseja chamar quando o delegado for chamado.

Delegados não associados são especialmente úteis se você quiser iterar por meio dos objetos em uma coleção – usando as palavras-chave for each, in – e chamar uma função membro em cada instância.

Veja como declarar, instanciar e chamar delegados associados e não associados:

Ação	Delegados associados	Delegados não associados
Declare	A assinatura do delegado deve corresponder à assinatura da função que você deseja chamar por meio do delegado.	O primeiro parâmetro da assinatura do delegado é o tipo de `this` para o objeto que você deseja chamar. Após o primeiro parâmetro, a assinatura do delegado deve corresponder à assinatura da função que você deseja chamar por meio do delegado.
Criar uma instância	Ao criar uma instância de um delegado associado, você pode especificar uma função de instância ou uma função de membro global ou estática. Para especificar uma função de instância, o primeiro parâmetro é uma instância do tipo cuja função membro você deseja chamar e o segundo parâmetro é o endereço da função que você deseja chamar. Se você quiser chamar uma função membro global ou estática, basta passar o nome de uma função global ou o nome da função membro estática.	Ao instanciar um delegado não associado, basta passar o endereço da função que você deseja chamar.
Chamar	Ao chamar um delegado associado, basta passar os parâmetros que são exigidos pela assinatura do delegado.	É da mesma forma que para um delegado associado, mas lembre-se de que o primeiro parâmetro deve ser uma instância do objeto que contém a função que você deseja chamar.

Este exemplo demonstra como declarar, instanciar e chamar delegados não associados:

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

Saída

O exemplo a seguir mostra como usar delegados não associados e as palavras-chave for each, in para iterar por meio de objetos em uma coleção e chamar uma função membro em cada instância.

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

Este exemplo cria um delegado não associado às funções do acessador de uma propriedade:

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

Saída

O exemplo a seguir mostra como invocar um delegado multicast, em que uma instância está associada e uma instância está desvinculada.

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

Saída

in f(R ^ r)
in f()

O exemplo a seguir mostra como criar e chamar um delegado genérico não associado.

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

Saída

12
14

Confira também

delegado (Extensões de componentes do C++)

Compartilhar via

Como definir e usar delegados (C++/CLI)

Como compor delegados

Transmita um delegado^ para uma função nativa que aguarda um ponteiro de função

Para associar delegados a funções não gerenciadas

Para usar delegados não associados

Confira também

Comentários

Recursos adicionais