L'appel de dll c++ fonctions retournant char* en c#. Ne peut pas utiliser DllImport()

J'ai une dll c++ avec 2 fonctions

const char* getVersionText1(void);
void        getVersionText2(const char** res);

À la fois une fonction retourne une chaîne de caractères décrivant la version du produit. La première fonction retourne comme const char* (ce qui signifie qu'il alloue et traiter localise en interne) et la seconde, on obtient un pointeur de type char* et juste à point pour un char* décrivant la version.

Je tiens à appeler ces fonctions à partir de C# et de l'affichage du texte.
Je ne peux pas utiliser [dllimport ...] de style depuis la commande de l'appel des fonctions est important. J'ai d'abord appeler le constructeur de getVersion et enfin le destructeur. Dll doit être chargée en mémoire.

Pouvez-vous s'il vous plaît poster les quelques lignes de codes que l'impression du texte pour les deux fonctions.
Je suis novice en C#, donc désolé si vous trouvez mon code problématique
J'ai essayé

static class NativeMethods{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LoadLibrary(string dllToLoad);
    [DllImport("kernel32.dll")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    public static extern bool FreeLibrary(IntPtr hModule);
}
class Program{
    //Define function pointers to entires in DLL
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate IntPtr getVersionText1();
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate void getVersionText2(IntPtr );
    static void Main(string[] args){
        //Pointers to functions of DLL.
        getVersionText1 f1;
        getVersionText2 f2;
        IntPtr pDll = NativeMethods.LoadLibrary("p:\\my.dll");
        IntPtr pAddressOfFunctionToCall;
        pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "getVersionText1 ");
        f1 = (getVersionText1)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall, typeof(getVersionText1));
        pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "getVersionText2 ");
        f2 = (getVersionText2)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall, typeof(getVersionText2));

        //Here I don't know what to do. It doesn't work ????
        IntPtr verText = f1();
        String s = Marshal.PtrToStringAuto(verText);
        Console.WriteLine(s);   //Doesnt work
        //And how to use the second function. How do I sent a pointer to char* ???
    }
}

Êtes-vous sûr getVersionText1 et getVersionText2 sont les vrais noms des fonctions exportées? C++ name mangling habituellement des changements de votre exporté noms. Vous pouvez vérifier la exporté noms avec n'importe quelle DLL export viewer.
J'en suis sûr. J'ai écrit la DLL en C++
Vous pourriez faire un manged C++/CLI wrapper DLL pour servir en tant que communicateur entre le C++ et le code C#

OriginalL'auteur DanielHsH | 2013-02-19

c#c++character-encoding dll

Voici une façon de faire de vos appels. Il y a peut être plus courte alternatives que d'effectuer la utf8/conversions de chaînes automatiquement.

[DllImport("mydll.dll")]
public static extern IntPtr getVersionText1(void);
public string getVersionTextConst()
{
    IntPtr ptr = getVersionText1();
    //assume returned string is utf-8 encoded
    return PtrToStringUtf8(ptr);
}

[DllImport("mydll.dll")]
public static extern void getVersionText2(out IntPtr res);
public string getVersionTextConst()
{
    IntPtr ptr;
    getVersionText2(ptr);
    //assume returned string is utf-8 encoded
    String str = PtrToStringUtf8(ptr);
    //call native DLL function to free ptr
    //if no function exists, pinvoke C runtime's free()
    return str;
}

private static string PtrToStringUtf8(IntPtr ptr) //aPtr is nul-terminated
{
    if (ptr == IntPtr.Zero)
        return "";
    int len = 0;
    while (System.Runtime.InteropServices.Marshal.ReadByte(ptr, len) != 0)
        len++;
    if (len == 0)
        return "";
    byte[] array = new byte[len];
    System.Runtime.InteropServices.Marshal.Copy(ptr, array, 0, len);
    return System.Text.Encoding.UTF8.GetString(array);
}

l'utilisation de getVersionText1() fonctionne. Merci! Mais je ne peux pas définir getVersionText2(IntPtr* res), car le compilateur ne crie que les pointeurs ne sont pas autorisés à être utilisés dans le contexte sécurisé. WTF est sûre contexte??? J'ai vu que vous utilisez "dangereux" mot clé, mais je ne suis pas sûr que je suis autorisé à l'utiliser car l'ensemble de l'application est sûr
Vous pouvez activer l'utilisation de code unsafe à partir de l'explorateur de solutions -> Propriétés -> Build -> Autoriser le code unsafe
Je ne peux pas utiliser dangereuse depuis ma DLL est intégré dans l'application tierce et je ne peux pas forcer le client à l'utilisation dangereuse de la compilation. Mais la solution est le mot clé 'IntPtr' au lieu de 'IntPtr*'
Merci, votre suggestion est beaucoup mieux. J'ai mis à jour ma réponse en conséquence.

OriginalL'auteur simonc

8

Si la bibliothèque C++ de la fonction renvoie char*, C# code de la traiter comme IntPtr et Marshal.PtrToStringAnsi() va la convertir en C# string.
```
IntPtr verText = f1();
string s = Marshal.PtrToStringAnsi(verText);
Console.WriteLine(s);
```
Merci beaucoup!! c'était très serviable...

OriginalL'auteur Thach Van
0

Si vous avez besoin de plus de vitesse, vous pouvez également faire une dangereux de lire:
```
unsafe string GetString(IntPtr ptr) => new string((char*)ptr); //local function

IntPtr charPtr = f1();
var s = GetString(charPtr);
```
Lorsque vous ajoutez le unsafe méthode, VS vous demande si vous souhaitez autoriser dangereux code du projet: répondre oui. Ou manuellement "propriétés du projet/construire/autoriser le code unsafe".

OriginalL'auteur Soleil

Vous devez vous connecter pour publier un commentaire.