Ejemplo Callback

En este ejemplo se demuestra cómo pasar delegados a una función no administrada que espera recibir punteros a función. Un delegado es una clase que puede contener una referencia a un método y equivale a un puntero a función con seguridad de tipos o una función de devolución de llamada.

Nota

Cuando se utiliza un delegado dentro de una llamada, Common Language Runtime lo protege contra la recolección de elementos no utilizados durante el tiempo que dure la llamada.Sin embargo, si la función no administrada almacena el delegado para usarlo al finalizar la llamada, debe impedir manualmente la recolección de elementos no utilizados hasta que la función no administrada deje de usar el delegado.Para obtener más información, vea Ejemplo HandleRef y Ejemplo GCHandle.

En el ejemplo Callback se utilizan las siguientes funciones no administradas, que se muestran con su declaración de función original:

• TestCallBack exportada desde PinvokeLib.dll.

  void TestCallBack(FPTR pf, int value);
  

• TestCallBack2 exportada desde PinvokeLib.dll.

  void TestCallBack2(FPTR2 pf2, char* value);
  

PinvokeLib.dll es una biblioteca personalizada y no administrada que contiene una implementación para las funciones enumeradas anteriormente.

En este ejemplo, la clase LibWrap contiene prototipos administrados para los métodos TestCallBack y TestCallBack2. Ambos métodos pasan un delegado a una función de devolución de llamada como parámetro. La firma del delegado debe coincidir con la del método al que hace referencia. Por ejemplo, los delegados FPtr y FPtr2 tienen firmas idénticas a las de los métodos DoSomething y DoSomething2.

Declaración de prototipos

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

Public Class LibWrap
    ' Declares managed prototypes for unmanaged functions.
    Declare Sub TestCallBack Lib "..\LIB\PinvokeLib.dll" ( ByVal cb _
        As FPtr, ByVal value As Integer )

    Declare Sub TestCallBack2 Lib "..\LIB\PinvokeLib.dll" ( ByVal cb2 _
        As FPtr2, ByVal value As String[])
End Class

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

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

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

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

public ref class LibWrap
{
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);
};

Llamadas a funciones

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

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

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

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

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

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

public ref class App
{
public:
    static void Main()
    {
        FPtr^ cb = gcnew FPtr(&App::DoSomething);
        LibWrap::TestCallBack(cb, 99);
        FPtr2^ cb2 = gcnew FPtr2(&App::DoSomething2);
        LibWrap::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;
    }
};

Vea también

Conceptos

Diversos ejemplos de cálculo de referencias

Tipos de datos de invocación de plataforma

Crear prototipos en código administrado