Le passage de pointeurs de code non managé

J'ai un projet C# que les importations d'une dll C, la dll a cette fonction:

int primary_read_serial(int handle, int *return_code, int *serial, int length);

Je veux avoir accès à la série de paramètres. En fait, j'ai eu le retour d'un personnage de la série de paramètres, mais je ne suis pas vraiment sûr de ce que je fais, je voudrais comprendre ce qui se passe, et bien sûr qu'il fonctionne.

Donc, je suis très sûr que la dll est en cours d'accès, d'autres fonctions sans pointeurs, beau travail. Comment gérer les pointeurs? Dois-je le maréchal? J'ai peut-être d'avoir un lieu fixe pour mettre les données?

Une explication serait génial.

Merci!
Richard

OriginalL'auteur Richard | 2009-05-07

  1. 8

    Vous aurez à utiliser un IntPtr et le Maréchal qui IntPtr dans quelque structure C# vous voulez le placer. Dans votre cas, vous devrez maréchal à un int[].

    Ceci est fait en plusieurs étapes:

    • Allouer un non géré poignée
    • Appeler la fonction avec la unamanged tableau
    • Convertir le tableau pour la gestion de tableau d'octets
    • Convertir en tableau d'octets int tableau
    • Version non géré poignée

    Que le code devrait vous donner une idée:

    //The import declaration
[DllImport("Library.dll")]
public static extern int primary_read_serial(int, ref int, IntPtr, int) ;


//Allocate unmanaged buffer
IntPtr serial_ptr = Marshal.AllocHGlobal(length * sizeof(int));

try
{
    //Call unmanaged function
    int return_code;
    int result = primary_read_serial(handle, ref return_code, serial_ptr, length);

    //Safely marshal unmanaged buffer to byte[]
    byte[] bytes = new byte[length * sizeof(int)];
    Marshal.Copy(serial_ptr, bytes, 0, length);

    //Converter to int[]
    int[] ints = new int[length];
    for (int i = 0; i < length; i++)
    {
        ints[i] = BitConverter.ToInt32(bytes, i * sizeof(int));
    }

}
finally
{
    Marshal.FreeHGlobal(serial_ptr);
}

    N'oubliez pas le try-finally, ou vous risque de fuite non managé poignée.

    Plus précisément, allouer un tableau non managé et géré int[] et le Maréchal.Copie de votre IntPtr à partir du tableau non managé géré.
    try-catch ou essayez-enfin?
    essayez-enfin, merci pour le tuyau. Fixe.

    OriginalL'auteur Coincoin

  2. 2

    Si je comprends ce que vous essayez de le faire, cela devrait fonctionner pour vous.

    unsafe
{
    int length = 1024; //Length of data to read.

    fixed (byte* data = new byte[length]) //Pins array to stack so a pointer can be retrieved.
    {
        int returnCode;
        int retValue = primary_read_serial(0, &returnCode, data, length);

        //At this point, `data` should contain all the read data.
    }
}

    JaredPar vous donne un moyen facile de le faire cependant, ce qui est juste pour changer votre déclaration de fonction de sorte que le C# n'sur la formation pour vous dans le fond.

    J'espère que cela vous donne une idée de ce qui se passe à un niveau légèrement inférieur, de toute façon.

    OriginalL'auteur Noldorin

  3. 0

    Lors de l'écriture de votre P/invoke déclaration de cette fonction, essayez d'utiliser le mot clé ref pour le pointeur de paramètres comme ceci:

    [DllImport("YouDll.dll", EntryPoint = "primary_read_serial")]
public static extern int primary_read_serial(int, ref int, ref int, int) ;

    Je ne suis pas sûr si vous devez spécifier les paramètres " nom en C#. Et n'oubliez pas, lorsque vous appelez cette méthode, vous devez utiliser les ref dans les arguments que vous êtes de passage par référence.

    Si c'est censé être un tableau, il doit faire en sorte de passer comme un IntPtr et le Maréchal.Copie d'une matrice.

    OriginalL'auteur Anzurio