Partilhar via

Como: Implementar funções de retorno de chamada

  • Artigo

O procedimento e o exemplo a seguir demonstram como um aplicativo gerenciado, usando a invocação de plataforma, pode imprimir o valor do identificador para cada janela no computador local. Especificamente, o procedimento e o exemplo usam a função EnumWindows para percorrer a lista de janelas e uma função de retorno de chamada gerenciada (chamada CallBack) para imprimir o valor do identificador de janela.

Para implementar uma função de retorno de chamada

  1. Observe a assinatura da função EnumWindows antes de prosseguir com a implementação. EnumWindows tem a seguinte assinatura:

    BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

    Uma pista de que essa função requer um retorno de chamada é a presença do argumento lpEnumFunc . É comum ver o prefixo lp (ponteiro longo) combinado com o sufixo Func no nome de argumentos que levam um ponteiro para uma função de retorno de chamada. Para obter documentação sobre funções Win32, consulte o Microsoft Platform SDK.

  2. Crie a função de retorno de chamada gerenciado. O exemplo declara um tipo de delegado, chamado CallBack, que usa dois argumentos (hwnd e lparam). O primeiro argumento é uma alça para a janela; O segundo argumento é definido pela aplicação. Nesta versão, ambos os argumentos devem ser inteiros.

    As funções de retorno de chamada geralmente retornam valores diferentes de zero para indicar sucesso e zero para indicar falha. Este exemplo define explicitamente o valor de retorno como true para continuar a enumeração.

  3. Crie um delegado e passe-o como um argumento para a função EnumWindows . Platform invoke converte o delegado em um formato de retorno de chamada familiar automaticamente.

  4. Certifique-se de que o coletor de lixo não recupere o delegado antes que a função de retorno de chamada conclua seu trabalho. Quando você passa um delegado como um parâmetro ou passa um delegado contido como um campo em uma estrutura, ele permanece não coletado durante a chamada. Assim, como é o caso no exemplo de enumeração a seguir, a função de retorno de chamada conclui seu trabalho antes que a chamada retorne e não requer nenhuma ação adicional por parte do chamador gerenciado.

    Se, no entanto, a função de retorno de chamada puder ser invocada após o retorno da chamada, o chamador gerenciado deverá tomar medidas para garantir que o delegado permaneça não coletado até que a função de retorno de chamada seja concluída. Para obter um exemplo, consulte o exemplo GCHandle.

Exemplo

Imports System  
Imports System.Runtime.InteropServices  
  
Public Delegate Function CallBack( _  
hwnd As Integer, lParam As Integer) As Boolean  
  
Public Class EnumReportApp  
  
    Declare Function EnumWindows Lib "user32" ( _  
       x As CallBack, y As Integer) As Integer  
  
    Public Shared Sub Main()  
        EnumWindows(AddressOf EnumReportApp.Report, 0)  
    End Sub 'Main  
  
    Public Shared Function Report(hwnd As Integer, lParam As Integer) _  
    As Boolean  
        Console.Write("Window handle is ")  
        Console.WriteLine(hwnd)  
        Return True  
    End Function 'Report  
End Class 'EnumReportApp  

using System;  
using System.Runtime.InteropServices;  
  
public delegate bool CallBack(int hwnd, int lParam);  
  
public class EnumReportApp  
{  
    [DllImport("user32")]  
    public static extern int EnumWindows(CallBack x, int y);
  
    public static void Main()
    {  
        CallBack myCallBack = new CallBack(EnumReportApp.Report);  
        EnumWindows(myCallBack, 0);  
    }  
  
    public static bool Report(int hwnd, int lParam)  
    {
        Console.Write("Window handle is ");  
        Console.WriteLine(hwnd);  
        return true;  
    }  
}  

using namespace System;  
using namespace System::Runtime::InteropServices;  
  
// A delegate type.  
delegate bool CallBack(int hwnd, int lParam);  
  
// Managed type with the method to call.  
ref class EnumReport  
{  
// Report the window handle.  
public:  
    [DllImport("user32")]  
    static int EnumWindows(CallBack^ x, int y);  
  
    static void Main()  
    {  
        EnumReport^ er = gcnew EnumReport;  
        CallBack^ myCallBack = gcnew CallBack(&EnumReport::Report);  
        EnumWindows(myCallBack, 0);  
    }  
  
    static bool Report(int hwnd, int lParam)  
    {  
       Console::Write(L"Window handle is ");  
       Console::WriteLine(hwnd);  
       return true;  
    }  
};  
  
int main()  
{  
    EnumReport::Main();  
}

Consulte também