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

  • Artigo

Declara um tipo que representa um ponteiro de função.

Todos os Runtimes

O Windows Runtime e o common language runtime dão suporte a delegados.

Comentários

delegate é uma palavra-chave contextual. Saiba mais em Palavras-chave contextuais.

Para detectar em tempo de compilação se um tipo é um delegado, use o traço de tipo __is_delegate(). Saiba mais em Suporte para compilador de traços de tipo.

Windows Runtime

O C++/CX é compatível com delegados com a sintaxe a seguir.

Sintaxe

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

Parâmetros

access
(opcional) A acessibilidade do delegado, que pode ser public (padrão) ou private. O protótipo de função também pode ser qualificado com as palavras-chaves const ou volatile.

return-type
O tipo de retorno do protótipo da função.

delegate-type-identifier
O nome do tipo de delegado declarado.

parameters
(Opcional) Os tipos e identificadores do protótipo da função.

Comentários

Use o delegate-type-identifier para declarar um evento com o mesmo protótipo que o delegado. Saiba mais em Delegates (C++/CX).

Requisitos

Opção do compilador: /ZW

Common Language Runtime

O common language runtime é compatível com delegates com a sintaxe a seguir.

Sintaxe

access
delegate
function_declaration

Parâmetros

access
(opcional) A acessibilidade de delegate fora do assembly pode ser public ou private. O padrão é private. Dentro de uma classe, um delegado pode ter qualquer acessibilidade.

function_declaration
A assinatura da função que pode ser associada ao delegado. O tipo de retorno de um delegado pode ser qualquer tipo gerenciado. Por motivos de interoperabilidade, recomendamos que o tipo de retorno de um delegado seja do tipo CLS.

Para definir um delegado não associado, o primeiro parâmetro em function_declaration deve ser o tipo do ponteiro this do objeto.

Comentários

Os delegados são multicast: o "ponteiro da função" pode ser associado a um ou mais métodos dentro de uma classe gerenciada. A palavra-chave delegate define um tipo de delegado multicast com uma assinatura de método específica.

Um delegado também pode ser associado a um método de uma classe de valor, como um método estático.

Um delegado tem as seguintes características:

  • Herda de System::MulticastDelegate.

  • Tem um construtor que utiliza dois argumentos: um ponteiro para uma classe gerenciada ou NULL (no caso de associação a um método estático) e um método totalmente qualificado do tipo especificado.

  • Tem um método chamado Invoke, cuja assinatura corresponde à assinatura declarada do delegado.

Quando um delegado é invocado, suas funções são chamadas na ordem em que foram anexados.

O valor de retorno de um delegado é o valor de retorno de sua última função de membro anexada.

Não é possível sobrecarregar delegados.

É possível associar ou desassociar.

Ao instanciar um delegado associado, o primeiro argumento deve ser uma referência ao objeto. O segundo argumento de uma instanciação de delegado deve ser o endereço de um método de um objeto de classe gerenciada ou um ponteiro para um método de um tipo de valor. O segundo argumento de uma instanciação de delegado deve nomear o método com a sintaxe de escopo de classe completa e aplicar o operador address-of.

Ao instanciar um delegado não associado, o primeiro argumento deve ser o endereço de um método de um objeto de classe gerenciada ou um ponteiro para um método de um tipo de valor. O argumento deve nomear o método com a sintaxe de escopo de classe completa e aplicar o operador address-of.

Ao criar um delegado para uma função global ou estática, apenas um parâmetro é necessário: a função (e, opcionalmente, o endereço da função).

Saiba mais sobre delegados em

Requisitos

Opção do compilador: /clr

Exemplos

O exemplo a seguir mostra como declarar, inicializar e invocar delegados.

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

Confira também

Extensões de componentes para .NET e UWP