Dela via

Marshalling a Delegate as a Callback Method

  • Artikel

Det här exemplet visar hur du skickar ombud till en ohanterad funktion som förväntar sig funktionspekare. Ett ombud är en klass som kan innehålla en referens till en metod och som motsvarar en typsäker funktionspekare eller en motringningsfunktion.

Kommentar

När du använder ett ombud i ett anrop skyddar den vanliga språkkörningen ombudet från att samlas in skräp under hela samtalet. Men om den ohanterade funktionen lagrar ombudet som ska användas när anropet har slutförts måste du manuellt förhindra skräpinsamling tills den ohanterade funktionen har slutförts med ombudet. Mer information finns i HandleRef-exempel och GCHandle-exempel.

Motringningsexemplet använder följande ohanterade funktioner som visas med den ursprungliga funktionsdeklarationen:

  • TestCallBack exporteras från PinvokeLib.dll.

    void TestCallBack(FPTR pf, int value);

  • TestCallBack2 exporteras från PinvokeLib.dll.

    void TestCallBack2(FPTR2 pf2, char* value);

PinvokeLib.dll är ett anpassat ohanterat bibliotek som innehåller en implementering för tidigare listade funktioner.

I det här exemplet NativeMethods innehåller klassen hanterade prototyper för TestCallBack metoderna och TestCallBack2 . Båda metoderna skickar ett ombud till en återanropsfunktion som en parameter. Ombudets signatur måste matcha signaturen för den metod som den refererar till. Ombuden FPtr och FPtr2 har till exempel signaturer som är identiska med DoSomething metoderna och DoSomething2 .

Deklarera prototyper

public delegate bool FPtr(int value);
public delegate bool FPtr2(String^ value);

private ref class NativeMethods
{
public:
    // Declares managed prototypes for unmanaged functions.
    [DllImport("..\\LIB\\PinvokeLib.dll")]
    static void TestCallBack(FPtr^ cb, int value);

    [DllImport("..\\LIB\\PinvokeLib.dll")]
    static void TestCallBack2(FPtr2^ cb2, String^ value);
};

public delegate bool FPtr(int value);
public delegate bool FPtr2(string value);

internal static class NativeMethods
{
    // Declares managed prototypes for unmanaged functions.
    [DllImport("..\\LIB\\PinvokeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    internal static extern void TestCallBack(FPtr cb, int value);

    [DllImport("..\\LIB\\PinvokeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    internal static extern void TestCallBack2(FPtr2 cb2, string value);
}


Public Delegate Function FPtr(ByVal value As Integer) As Boolean
Public Delegate Function FPtr2(ByVal value As String) As Boolean

Friend Class NativeMethods
    ' Declares managed prototypes for unmanaged functions.
    <DllImport("..\LIB\PinvokeLib.dll", CallingConvention:=CallingConvention.Cdecl)>
    Friend Shared Sub TestCallBack(
        ByVal cb As FPtr, ByVal value As Integer)
    End Sub

    <DllImport("..\LIB\PinvokeLib.dll", CallingConvention:=CallingConvention.Cdecl)>
    Friend Shared Sub TestCallBack2(
        ByVal cb2 As FPtr2, ByVal value As String)
    End Sub
End Class

Anropa funktioner

public ref class App
{
public:
    static void Main()
    {
        FPtr^ cb = gcnew FPtr(&App::DoSomething);
        NativeMethods::TestCallBack(cb, 99);
        FPtr2^ cb2 = gcnew FPtr2(&App::DoSomething2);
        NativeMethods::TestCallBack2(cb2, "abc");
    }

    static bool DoSomething(int value)
    {
        Console::WriteLine("\nCallback called with param: {0}", value);
        // ...
        return true;
    }

    static bool DoSomething2(String^ value)
    {
        Console::WriteLine("\nCallback called with param: {0}", value);
        // ...
        return true;
    }
};

public class App
{
    public static void Main()
    {
        FPtr cb = new FPtr(App.DoSomething);
        NativeMethods.TestCallBack(cb, 99);
        FPtr2 cb2 = new FPtr2(App.DoSomething2);
        NativeMethods.TestCallBack2(cb2, "abc");
    }

    public static bool DoSomething(int value)
    {
        Console.WriteLine($"\nCallback called with param: {value}");
        // ...
        return true;
    }

    public static bool DoSomething2(string value)
    {
        Console.WriteLine($"\nCallback called with param: {value}");
        // ...
        return true;
    }
}

Public Class App
    Public Shared Sub Main()
        Dim cb As FPtr = AddressOf App.DoSomething
        Dim cb2 As FPtr2 = AddressOf App.DoSomething2
        NativeMethods.TestCallBack(cb, 99)
        NativeMethods.TestCallBack2(cb2, "abc")
    End Sub

    Public Shared Function DoSomething(ByVal value As Integer) As Boolean
        Console.WriteLine(ControlChars.CrLf + $"Callback called with param: {value}")
        ' ...
        Return True
    End Function

    Public Shared Function DoSomething2(ByVal value As String) As Boolean
        Console.WriteLine(ControlChars.CrLf + $"Callback called with param: {value}")
        ' ...
        Return True
    End Function
End Class

Se även