C # Marshalling double * à partir de C ++ DLL?

J'ai une DLL C++ avec une fonction exportée:

extern "C" __declspec(dllexport) double* fft(double* dataReal, double* dataImag)
{
  [...]
}

La fonction calcule la FFT de les deux tableaux (réel et imaginaire) renvoie un double tableau avec le réel de l'imaginaire composants entrelacé: { Re, Mi, Ré, Mi, ... }

Je ne sais pas comment appeler cette fonction en C#.
Ce que je fais est:

[DllImport("fft.dll")]
static extern double[] fft(double[] dataReal, double[] dataImag);

et quand je l'ai tester comme ceci:

double[] foo = fft(new double[] { 1, 2, 3, 4 }, new double[] { 0, 0, 0, 0 });

- Je obtenir un MarshalDirectiveException exception:

Ne peut maréchal de "valeur de retour": les Invalides réussi/non géré type de combinaison.

Je suppose que c'est parce que le C++ double* n'est pas tout à fait la même qu'en C# double[]mais je ne suis pas sûr de la façon de le résoudre. Des idées?

Edit:
J'ai changé les signatures pour que je soit maintenant pass certaines informations supplémentaires:

extern "C" __declspec(dllexport) void fft(double* dataReal, double* dataImag, int length, double* output);

Nous savons toujours la longueur de output sera 2x length

et

[DllImport("fft.dll")]
static extern void fft(double[] dataReal, double[] dataImag, int length, out double[] output);

testé comme ceci:

double[] foo = new double[8];
fft(new double[] { 1, 2, 3, 4 }, new double[] { 0, 0, 0, 0 }, 4, out foo);

Maintenant, je suis pas un AccessViolationException plutôt qu'un MarshalDirectiveException.

source d'informationauteur Ozzah

  1. 11

    Il y a quelques problèmes avec votre exemple:

    1. Le code C++ n'a aucune idée de la taille de ces tableaux sont. Le marshaller passer un pointeur valide, mais sans la longueur correspondante paramètre, il n'y a aucun moyen de savoir comment ils sont gros. sizeof(dataReal) et sizeof(dataImag) est probablement 4 ou 8 sur la plupart des plates-formes (c'est à dire sizeof(void*)). Probablement pas ce que vous souhaitiez.
    2. Alors qu'il est possible de maréchal un pointeur de retour comme valeur de retour (vous pouvez ensuite l'utiliser pour remplir une matrice), il n'est pas implicite propriétaire de la valeur de retour de la mémoire, en laissant ouverte la possibilité de fuites de mémoire. A la mémoire tampon allouée à l'intérieur de la fft avec de nouvelles? Si oui, alors vous auriez besoin d'une autre exporter le code managé peuvent appeler pour libérer de la mémoire ou de l'utilisation LocalAlloc à la place (et puis Maréchal.FreeHGlobal, sur la gestion de côté). C'est au mieux problématique.

    Au lieu de cela, ma suggestion serait de définir la fft cette façon:

    
extern "C" __declspec(dllexport) void __stdcall fft(double const* dataReal, int dataRealLength, double const* dataImag, int dataImagLength, double* result, int resultLength)
{
  //Check that dataRealLength == dataImagLength
  //Check that resultLength is twice dataRealLength
}

    Le correspondant de P/Invoke signature:

    
[DllImport("fft.dll")]
static extern void fft(double[] dataReal, int dataRealLength, double[] dataImag, int dataImagLength, double[] result, int resultLength);

    Et puis un exemple d'appel:

    
double[] dataReal = new double[] { 1.0, 2.0, 3.0, 4.0 };
double[] dataImag = new double[] { 5.0, 6.0, 7.0, 8.0 };
double[] result = new double[8];
fft(dataReal, dataReal.Length, dataImag, dataImag.Length, result, result.Length);

    Edit: la mise à jour basé sur ce que la fft est décrit à faire.

  2. 2

    Il n'est pas nécessaire de modifier la signature.
    Vous pouvez utiliser la suite:

    [DllImport( "fft.dll", EntryPoint = "fft" )]
public static extern IntPtr fft( double[] dataReal, double[] dataImag );

    Alors vous aurez besoin de copier des octets retournés IntPtr. Puisque vous connaissez la taille de la sortie est le double de l'entrée, vous le faites de manière suivante:

    double[] result = new double[ doubleSize ];
Marshal.Copy( pointer, result, 0, doubleSize );

    La result contiendra octets retournés par le fft fonction.

    EDIT:
    Je crois que vous trouverez P/Invoke Interop Assistant outil utile: Géré en Natif, et COM Interop

  3. 1

    Ce n'est pas bon prototype pour l'interopérabilité. Vous pouvez deux façons de résoudre ce problème:

    1. Changement C++ prototype de fonction et retourner tous les doubles dans les paramètres (j'espère que vous avez la source de C++ func)
    2. Utilisation IntPtr comme décrit par le Reste de l'Aile

    Le retour de la mémoire de référence serait de travailler correctement que dans le cas où le mémoire a été allouée avec CoTaskMemAlloc fonction. Othrwise vous prendra exception d'exécution au cours de libérer de la mémoire (le CLR toujours essayer de libérer de l'returnning mémoire avec CoTaskMemFree).

    Je pense que le mieux serait de la première manière, il décrit en Pierre Huene de réponse.