Procedura: implementare funzioni di callbackHow to: Implement Callback Functions

La procedura e l'esempio seguenti illustrano come un'applicazione gestita, usando il platform invoke, può stampare il valore di handle per ogni finestra sul computer locale.The following procedure and example demonstrate how a managed application, using platform invoke, can print the handle value for each window on the local computer. In particolare, la procedura e l'esempio usano la funzione EnumWindows per esaminare l'elenco di finestre e una funzione di callback gestita (denominata CallBack) per visualizzare il valore di handle della finestra.Specifically, the procedure and example use the EnumWindows function to step through the list of windows and a managed callback function (named CallBack) to print the value of the window handle.

Per implementare una funzione di callbackTo implement a callback function

  1. Esaminare la firma per la funzione EnumWindows prima di procedere con l'implementazione.Look at the signature for the EnumWindows function before going further with the implementation. EnumWindows presenta in genere la firma seguente:EnumWindows has the following signature:

    BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)  
    

    Un’indicazione del fatto che questa funzione richiede un callback è la presenza dell'argomento lpEnumFunc.One clue that this function requires a callback is the presence of the lpEnumFunc argument. È frequente vedere il prefisso lp (puntatore di tipo long) combinato con il suffisso Func nel nome di argomenti che accettano un puntatore a una funzione di callback.It is common to see the lp (long pointer) prefix combined with the Func suffix in the name of arguments that take a pointer to a callback function. Per informazioni sulle funzioni Win32, vedere Microsoft Platform SDK.For documentation about Win32 functions, see the Microsoft Platform SDK.

  2. Creare la funzione di callback gestita.Create the managed callback function. L'esempio dichiara un tipo delegato, denominato CallBack, che accetta due argomenti (hwnd e lparam).The example declares a delegate type, called CallBack, which takes two arguments (hwnd and lparam). Il primo argomento è un handle alla finestra, mentre il secondo è definito dall'applicazione.The first argument is a handle to the window; the second argument is application-defined. In questa versione entrambi gli argomenti devono essere numeri interi.In this release, both arguments must be integers.

    Funzioni di callback restituiscono in genere valori diversi da zero per indicare l’esito positivo e zero per indicare l’esito negativo.Callback functions generally return nonzero values to indicate success and zero to indicate failure. Questo esempio imposta in modo esplicito il valore restituito su true per continuare l'enumerazione.This example explicitly sets the return value to true to continue the enumeration.

  3. Creare un delegato e passarlo come argomento alla funzione EnumWindows.Create a delegate and pass it as an argument to the EnumWindows function. Platform invoke converte automaticamente il delegato in un formato di callback conosciuto.Platform invoke converts the delegate to a familiar callback format automatically.

  4. Assicurarsi che il garbage collector non recuperi il delegato prima che venga completata la funzione di callback.Ensure that the garbage collector does not reclaim the delegate before the callback function completes its work. Quando si passa un delegato come parametro o si passa un delegato contenuto come campo in una struttura, questo non viene interessato per la durata della chiamata.When you pass a delegate as a parameter, or pass a delegate contained as a field in a structure, it remains uncollected for the duration of the call. Quindi, come nel seguente esempio di enumerazione, la funzione di callback viene completata prima che venga restituita la chiamata e non richiede operazioni aggiuntive dal chiamante gestito.So, as is the case in the following enumeration example, the callback function completes its work before the call returns and requires no additional action by the managed caller.

    Se, tuttavia, la funzione di callback può essere richiamata dopo che viene restituita la chiamata, il chiamante gestito deve provvedere a garantire che il delegato non venga interessato fino al completamento della funzione di richiamata.If, however, the callback function can be invoked after the call returns, the managed caller must take steps to ensure that the delegate remains uncollected until the callback function finishes. Per informazioni dettagliate su come evitare operazioni di Garbage Collection, vedere Marshalling di interoperabilità con platform invoke.For detailed information about preventing garbage collection, see Interop Marshaling with Platform Invoke.

EsempioExample

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

Vedere ancheSee Also

Funzioni di callbackCallback Functions
Chiamata a una funzione di DLLCalling a DLL Function