Appel fonction "C" en "C#" ("CALLBACK" + "Unicode")

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous,

J'ai rencontré un problème avec l'appel d'une fonction "C" dans "C#".

La fonction "C" reçu en argument un pointeur de fonction "CALLBACK" implantée en "C#", et elle appelle cette dernière à son tour en lui passant un paramètre de type "chaîne de caractères" (type "string" côté "C#").

Code "C" :
Code:

1 2 3 4 5 6 7 8 9 typedef void (__stdcall *PRETURNUNICODESTRINGCALLBACK)(const wchar_t *lpszText); __declspec(dllexport) void ReturnUnicodeStringProc(PRETURNUNICODESTRINGCALLBACK pReturnStringCallback) { pReturnStringCallback(L"Data"); }
Code "C#":
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 private delegate void DoSomethingCallbackProc(string lpszText); [DllImport("SampleDLL.dll", CharSet = CharSet.Unicode)] private static extern void ReturnUnicodeStringProc(DoSomethingCallbackProc proc); static void Main(string[] args) { ReturnUnicodeStringProc(new DoSomethingCallbackProc(DoSomethingCallback)); } private static void DoSomethingCallback(string lpszText) { int i = 0; }
Si la fonction "C" passe une chaîne de type "MBCS" à la fonction "CALLBACK" en "C#", tout fonctionne bien. Mais si c'est une chaîne "Unicode" qui est retournée, seul le premier caractère est correctement transcrit dans l'objet "string" de "C#".

Je joins avec ce message un code exemple qui démontre ce problème.

Je vous remercie par avance de votre aide

31/01/2012, 07h26
DonQuiche

Bonjour, as-tu essayé ceci ?

Code:

private delegate void DoSomethingCallbackProc([MarshalAs(UnmanagedTypes.LPWStr)] string lpszText);
31/01/2012, 09h14
Bluedeep
Bonjout

Citation:

Envoyé par DonQuiche

, as-tu essayé ceci ?

Code:

private delegate void DoSomethingCallbackProc([MarshalAs(UnmanagedTypes.LPWStr)] string lpszText);

Presque; mais utiliser en plus l'attribut :

Code:

[MarshalAs(UnmanagedType.FunctionPtr)]

Quelque chose comme ça :
Code:

1 2 [DllImport("SampleDLL.dll", CharSet = CharSet.Unicode)] private static extern void ReturnUnicodeStringProc([MarshalAs(UnmanagedType.FunctionPtr)]DoSomethingCallbackProc proc);
et dans le delegate, en effet :

Code:

private delegate void DoSomethingCallbackProc([MarshalAs(UnmanagedType.LPWStr)]string lpszText);

Sans garantie, mais la solution est approximativement celle là.
31/01/2012, 21h56
Raphael ZHOU

Cool! ça marche. Merci beaucoup! :ccool:

Code:

1
2
3
4
5
6
7
8
 
        private delegate void DoSomethingCallbackProc([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StringAutoMarshaler))]string lpszText);
 
        [DllImport("SampleDLL.dll")]
        private static extern void ReturnUnicodeStringProc(DoSomethingCallbackProc proc);
 
        [DllImport("SampleDLL.dll")]
        private static extern void ReturnMBCSStringProc(DoSomethingCallbackProc proc);

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
class StringAutoMarshaler: ICustomMarshaler
{
    public static ICustomMarshaler GetInstance(String cookie)
    {
        return (new StringAutoMarshaler());
    }
 
    object ICustomMarshaler.MarshalNativeToManaged(IntPtr pNativeData)
    {
        return ((Marshal.ReadInt16(pNativeData) & 0xFF00) == 0 ? Marshal.PtrToStringUni(pNativeData) : Marshal.PtrToStringAnsi(pNativeData));
    }
 
    void ICustomMarshaler.CleanUpManagedData(object ManagedObj)
    {
    }
 
    void ICustomMarshaler.CleanUpNativeData(IntPtr pNativeData)
    {
        throw new NotImplementedException();
    }
 
    int ICustomMarshaler.GetNativeDataSize()
    {
        throw new NotImplementedException();
    }
 
    IntPtr ICustomMarshaler.MarshalManagedToNative(object ManagedObj)
    {
        throw new NotImplementedException();
    }
}

EDIT:
Je suis étonné que la solution donnée par Bluedeep fonctionne. Parce que

Code:

1
2
3
[DllImport("SampleDLL.dll", CharSet = CharSet.Unicode)]
private static extern void ReturnUnicodeStringProc([MarshalAs(UnmanagedType.FunctionPtr)]DoSomethingCallbackProc proc);

Tout ce qui est en rouge ne sert à rien.

Le prob c'est juste que le C++ appelle 1 delegate via 2 proto C++.

Code:

1
2
3
4
 
typedef void (__stdcall *PRETURNMBCSSTRINGCALLBACK)(const char *lpszText);
 
typedef void (__stdcall *PRETURNUNICODESTRINGCALLBACK)(const wchar_t *lpszText);

et donc ça se résume à pouvoir décorer le param lpszText du delegate pour dire "des fois c'est ANSI d'autres fois c'est UNICODE".
et

Code:

private delegate void DoSomethingCallbackProc([MarshalAs(UnmanagedType.LPWStr)]string lpszText);

ne marche que pour un cas : "marshal moi ça en sachant que l'input est un pointeur sur une chaine Unicode".
Je ne sais pas si j'ai été clair. Si j'ai faux, je veux bien qu'on m'explique mon probleme de raisonnement !!

EDIT 2: :aie: Je viens de relire, je suis un boulet! Il passe *TOUJOURS* un ptr sur une chaîne Unicode.