Interface d'une DLL C vers .NET

Question

J'ai une ancienne DLL écrite en C que j'aimerais appeler à partir d'une application C # .NET. Le problème est que l'interface de la DLL C est assez compliquée. C'est quelque chose comme ça:

__declspec(dllexport) void __stdcall ProcessChunk(
    void *p_prochdl,
    const BIG_INPUT_STRC *p_inparams,
    BIG_OUTPUT_STRC *p_outparams
);

Les BIG_INPUT_STRC / BIG_OUTPUT_STRC contiennent toutes sortes de choses ... des pointeurs sur des tableaux de mémoire tampon, des paramètres énumérés, des paramètres entiers, etc. En bref, ils sont compliqués.

Première question: existe-t-il un moyen simple d’obtenir toutes les informations de structure contenues dans le fichier d’en-tête de DLL dans la classe C #, ou devez-vous littéralement copier et coller tout dans C # et le redéfinir? Cela semble redondant.

En rapport avec cela, quelle est la bonne façon de passer des structures dans la DLL non gérée à partir de C #?

Enfin, existe-t-il un exemple montrant comment passer correctement des matrices de mémoire tampon de C # dans la DLL non gérée? Sinon, comment puis-je passer un tableau à deux dimensions dans la DLL?

Merci, -Greg

Answer 1

Il est assez simple de faire ce soft en C # en utilisant P / Invoke.

Je pense que vous allez devoir définir manuellement les structures de données en C #.

Je vous conseillerais de consulter cet article MSDN . sur le sujet

Answer 2

Vous devrez largement utiliser le marshalling . Vous devez d’abord redéfinir les structures C dans votre code C #, puis vous assurer que tout est correctement marshalle à l’aide des attribut MarshalAs .

Si vous devez renvoyer un pointeur sur la structure en C # à la fonction C, vous pouvez utiliser Marshal.StructToPtr .

Les tableaux de mémoire tampon, en supposant qu'ils soient définis en tant qu'octet [], peuvent être combinés à l'aide de la technique suivante:

byte[] buffer = ...;
fixed(byte *pBuffer = buffer)
{
   // do something with the pBuffer
}

L'instruction fixed s'assure que le tampon ne soit pas déplacé dans la mémoire par le récupérateur de mémoire, ce qui rend le pointeur dans l'instruction 'fixed' ou 'épinglé'.

En ce qui concerne les tableaux multidimensionnels, cela dépend de l’implémentation C sous-jacente. Vous pouvez par exemple travailler avec un pointeur sur le tableau et ajuster la position en fonction du nombre de dimensions et du nombre d’éléments dans chaque dimension, comme:

someValue = buffer[(elementsPerDimensions * x) + y];

D'après votre description, cela semble déjà assez compliqué. Avez-vous envisagé de rendre votre bibliothèque conviviale?

Answer 3

Quelle pilule.

1. J'éviterais d'essayer de rendre la bibliothèque conviviale pour la bibliothèque. C'est plus de problèmes que sa valeur.

2. Je construirais une deuxième bibliothèque native avec des fonctions conçues pour être P / INVOKED afin de créer les enregistrements du premier et l'appeler.

Vous pouvez également créer une bibliothèque C ++ native / gérée pour gérer le marshaling.