Discussion :

[Invité(e)]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[theMonz31]

salut

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

[olibara]

Un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[tomlev]

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

Pas besoin du ref, IntPtr est suffisant

[Invité(e)]

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

[olibara]

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)

[tomlev]

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...)

[Invité(e)]

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

le client de la DLL écrit un fonction genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[olibara]

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

[olibara]

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

[tomlev]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité(e)]

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

Dans mon code je mixe donc du

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

DLL_enregistreCallback(mon_callback);

EDIT
le tout unsafe bien sur
/EDIT

un grand

[tomlev]

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

[Invité(e)]

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 ?

[tomlev]

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 )

[olibara]

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 !