Guide pratique pour implémenter des fonctions de rappel

La procédure et l’exemple suivants montrent comment une application managée, à l’aide d’un appel de plateforme, peut imprimer la valeur de handle pour chaque fenêtre sur l’ordinateur local. Plus précisément, la procédure et l’exemple utilisent la EnumWindows fonction pour parcourir la liste des fenêtres et une fonction de rappel managée (nommée CallBack) pour imprimer la valeur du handle de fenêtre.

Pour implémenter une fonction de rappel

  1. Examinez la signature de la EnumWindows fonction avant d’aller plus loin avec l’implémentation. EnumWindows a la signature suivante :

    BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

    L’un des indices que cette fonction nécessite un rappel est la présence de l’argument lpEnumFunc . Il est courant de voir l'indication lp (pointeur long) combinée au suffixe Func dans le nom des arguments qui prennent un pointeur vers une fonction de rappel. Pour plus d’informations sur les fonctions Win32, consultez le Kit de développement logiciel (SDK) de plateforme Microsoft.

  2. Créez la fonction de rappel managée. L’exemple déclare un type délégué, appelé CallBack, qui prend deux arguments (hwnd et lparam). Le premier argument est un identifiant de la fenêtre ; le deuxième argument est défini par l’utilisateur. Dans cette version, les deux arguments doivent être des entiers.

    Les fonctions de rappel retournent généralement des valeurs non nulles pour indiquer la réussite et zéro pour indiquer l’échec. Cet exemple définit explicitement la valeur de retour sur true pour poursuivre l’énumération.

  3. Créez un délégué et transmettez-le en tant qu’argument à la EnumWindows fonction. L'appel de code non managé convertit automatiquement le délégué au format de rappel habituel.

  4. Assurez-vous que le garbage collector ne récupère pas le délégué avant que la fonction de rappel n’ait effectué sa tâche. Quand vous transmettez un délégué en tant que paramètre ou un délégué contenu en tant que champ dans une structure, il n'est pas collecté pendant toute la durée de l'appel. Ainsi, comme c’est le cas dans l’exemple d’énumération suivant, la fonction de rappel termine son travail avant le retour de l’appel et ne nécessite aucune action supplémentaire par l’appelant géré.

    Si, toutefois, la fonction de rappel peut être appelée après le retour d'appel, l'appelant managé doit prendre des mesures pour s’assurer que le délégué n'est pas collecté jusqu’à ce que la fonction de rappel termine sa tâche. Pour obtenir un exemple, consultez l’exemple GCHandle.

Example

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

Voir aussi

  • Last updated on