interopérabilité C / C#

Bonjour,

Dans le cadre de mon travail, j'ai réalisé une DLL windows dont toute l'interface est en C. À priori (ce n'est pas moi qui l'utilise en C#), il est tout à fait possible d'appeler des fonctionS C depuis le C#.

Une des fonctions de cette DLL C utilise un système de callback : on enregistre à un moment une fonction que la DLL appellera toute seule le moment venu.

Le prototype du callback ressemble à

Code:

---

void __stdcall mon_callback(void*, size_t, size_t, int);

---

Du coup, comment, en C#, déclarer (ou définir) une méthode (ou une fonction) pour que son prototype et sa convention d'appel soit compatible avec le prototype C donné ?

Merci

mabu

salut

il faut que tu regardes du coté de l'interopérabilité et les mécanismes
P/Invoke :)

Un truc du genre

Code:

---

1 2 3

[DllImport("MaDll.Dll")] static public extern void mon_callback(ref IntPtr ptr, int a, int sz,int b);

---

Note l'usage de ref IntPtr ptr pour emuler ton void *

Je ne garranti pas le truc a 100% c'est généralement là qu'il faut touiller un peu en fonction de l'usage interne qui est fait de ce pointeur

Attention aussi aux size_t : j'ai mis int mais ca dépends de ton environnement c'est peut etre int64 !

Citation:

---

Envoyé par olibara

Note l'usage de ref IntPtr ptr pour emuler ton void *

---

Pas besoin du ref, IntPtr est suffisant

Merci pour vos réponses.

Je ne vais pouvoir tester vos suggestions tout de suite, mais dès que ça sera fait, je reviendrai vous dire comment ça se passe.

Merci encore

Citation:

---

Pas besoin du ref, IntPtr est suffisant

---

Pas forcément !

Tout dépends de la maniere dont ce void* est traité dans la dll
S'il est modifié c'est un ** et le ref devient nécessaire

(j'ai eu le cas)

Citation:

---

Envoyé par olibara

Pas forcément !

Tout dépends de la maniere dont ce void* est traité dans la dll
S'il est modifié c'est un ** et le ref devient nécessaire

(j'ai eu le cas)

---

ben dans ce cas c'est la signature C qui n'est pas correcte... ça devrait être un void** il me semble (mais bon, ça fait longtemps que j'ai pas fait du C...)

Alors en fait, en c ça se passe comme ça :

le client de la DLL écrit un fonction genre :

Code:

---

1 2 3 4 5

void __stdcall callback_client(void* data, size_t data_size, size_t foo, int bar) { /* le client travaille avec les data créés par la DLL */ printf("les data sont :%s", data); }

---

Le client ne modifie pas les data, il ne fait que les recevoir à intervalle régulier.

Il enregistre cette fonction auprès de la DLL :

Code:

---

DLL_enregistreCallBack(callback_client);

---

Et c'est la DLL qui va appeler (dans un thread séparé) la fonction du client quand des datas seront prêt.

Ma question porte donc sur : comment écrire une fonction C# pour pouvoir la donner en paramètre à ma fonction DLL_enregistreCallBack ?

Citation:

---

ben dans ce cas c'est la signature C qui n'est pas correcte... ça devrait être un void**

---

Tu a raison c'est moi qui me suis basé sur un mauvais exemple !

Par le jeu des typedef en C on finit par faire passer une vache pour un cochon !

Donc pour mabu c'est bien un IntPtr qu'il faut passer et pas un ref IntPtr

Citation:

---

Ma question porte donc sur : comment écrire une fonction C# pour pouvoir la donner en paramètre à ma fonction DLL_enregistreCallBack ?

---

Ouille !

Maintenant je comprends le problème et je serais tres curieux de voir s'il y a une solution :aie:

Il faut déclarer un delegate avec une signature qui correspond :

Code:

---

delegate void MonCallback(IntPtr data, int data_size, int foo, int bar);

---

Impec, ça a l'air de marcher à merveille...

Dans mon code je mixe donc du

Code:

---

1 2 3 4

delegate void LE_Callback(char* data, UInt32 data_size, UInt32 foo, Int32 bar);   [DllImport("madll.Dll")] static extern int DLL_enregistreCallback(LE_Callback func);

---

Code:

---

1 2 3 4

void mon_callback(char *pImage, UInt32 size, UInt32 foo, Int32 bar) { /* ... */ }

---

Code:

---

1 2	LE_Callback callback = new LE_Callback(this.mon_callback); DLL_enregistreCallback(callback );

---

Cela dit, la convention d'appel du c# a l'air d'être du stdcall puisse que si je me passe du delegate, le tout ne m'explose pas à la figure :

Code:

---

1 2 3 4

static void mon_callback(char *pImage, UInt32 size, UInt32 foo, Int32 bar) { /* ... */ }

---

Code:

---

DLL_enregistreCallback(mon_callback);

---

EDIT
le tout unsafe bien sur
/EDIT

un grand :merci:

Citation:

---

Envoyé par mabu

Cela dit, la convention d'appel du c# a l'air d'être du stdcall

---

Tu peux choisir la convention d'appel avec le champ CallingConvention de l'attribut DllImport

Citation:

---

Envoyé par tomlev

Tu peux choisir la convention d'appel avec le champ CallingConvention de l'attribut DllImport

---

Bon à savoir.

Une question par curiosité, y-a-t-il moyen de modifier la convention d'appel des fonctions écrites en c#. Aujourd'hui, la DLL c appelle ma fonction c# et tout se passe bien, mais que ce serait il passé si ma DLL attendait un cdecl ?

tu dois pouvoir utiliser UnmanagedFunctionPointerAttribute, qui semble être le pendant de DllImportAttribute pour les délégués... (je m'en suis jamais servi, je viens de découvrir son existence dans la doc ;))

Et bien je trouve que ce sujet est particulierement instructif !

Meci a mabu de l'avoir ouvert et a TomLev d'avoir si bien trouvé les réponses adéquates ! :king: