Megosztás a következőn keresztül:

Útmutató: Visszahívási függvények implementálása

Az alábbi eljárás és példa bemutatja, hogy egy platformhívást használó felügyelt alkalmazás hogyan tudja kinyomtatni a leíró értékét a helyi számítógépen lévő egyes ablakokhoz. Az eljárás és a példa az EnumWindows függvénnyel lépeget az ablakok listájában, és egy felügyelt visszahívási függvény (CallBack) segítségével nyomtatja ki az ablakleíró értékét.

Visszahívási függvény implementálása

  1. Mielőtt továbblép a megvalósításra, tekintse meg az EnumWindows függvény aláírását. Az EnumWindows a következő aláírást tartalmazza:

    BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

    A függvény visszahívást igénylő egyik nyoma az lpEnumFunc argumentum jelenléte. Gyakori, hogy az lp (hosszú mutató) előtag és a Func utótag szerepel azon argumentumok nevében, amelyek egy visszahívási függvényhez viszik az egérmutatót. A Win32-függvényekkel kapcsolatos dokumentációt a Microsoft Platform SDK-ban találja.

  2. Hozza létre a felügyelt visszahívási függvényt. A példa deklarál egy delegálttípust, amelynek neve CallBackkét argumentumot vesz fel (hwnd és lparam). Az első argumentum az ablak fogópontja; a második argumentum alkalmazás által definiált. Ebben a kiadásban mindkét argumentumnak egész számnak kell lennie.

    A visszahívási függvények általában nonzero értékeket adnak vissza a sikeresség, a nullát pedig a hiba jelzésére. Ez a példa kifejezetten igaz értékre állítja a visszatérési értéket az enumerálás folytatásához.

  3. Hozzon létre egy delegáltat, és adja át argumentumként az EnumWindows függvénynek . A platformhívás automatikusan ismerős visszahívási formátummá alakítja a meghatalmazottat.

  4. Győződjön meg arról, hogy a szemétgyűjtő nem vonja vissza a meghatalmazottat, mielőtt a visszahívási függvény befejezi a munkáját. Ha paraméterként ad át egy meghatalmazottat, vagy egy struktúra mezőjeként megadott meghatalmazottat ad át, az a hívás időtartama alatt nem lesz megadva. A következő számbavételi példához hasonlóan a visszahívási függvény a hívás visszatérése előtt befejezi a munkáját, és nem igényel további műveletet a felügyelt hívótól.

    Ha azonban a visszahívási függvény a hívás visszatérése után is meghívható, a felügyelt hívónak lépéseket kell tennie annak érdekében, hogy a delegált ne maradjon vissza, amíg a visszahívási függvény be nem fejeződik. Példaként tekintse meg a GCHandle-mintát.

Példa

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

Lásd még