Retourne la chaîne de dll c++ la fonction d'exportation est appelé à partir de c#

Je suis en train de retourner une chaîne de caractères à partir d'une dll c++ la fonction d'exportation. Je suis l'appel de cette fonction à partir de c#. J'ai vu beaucoup d'exemples sur internet et je suis vraiment confus quoi faire.

Mon code c++ de la fonction d'exportation:

extern "C" __declspec(dllexport)  char*  __cdecl getDataFromTable(char* tableName)
{
    std::string st = getDataTableWise(statementObject, columnIndex);
    printf(st.c_str()); 

    char *cstr = new char[st.length() + 1];
    strcpy(cstr, st.c_str());
    return cstr;
}

Quand j'essaie d'appeler cette fonction à partir de c#:

[DllImport("\\SD Card\\ISAPI1.dll")]
private static extern string getDataFromTable(byte[] tablename);
static void Main(string[] args)
{
    string str = getDataFromTable(byteArray);
    Console.writeLine(str);
}

J'ai eu une erreur lors de l'appel à elle. Je suis la création de ce pour WinCE 6.0

ÉDITÉ------------------------

est là quelque chose comme, je peux passer un tampon vide de c++, c# et c++ la fonction va remplir les données et je peux la réutiliser en C#

Quelle est l'erreur?
OutOfMemory Exception à la console.writeLine(String valeur)
Bien sûr, personne ne va appeler delete[] pour obtenir le tampon de chaîne d'espace libéré à nouveau. Qui se termine finalement avec OOM. Vous ne pouvez pas le faire de cette façon. Essayez CoTaskMemAlloc() en premier. Prenez de l'avance la prochaine en permettant à l'appelant de fournir le tampon, comme int getDataFromTable(char* nom de la table, char* tampon, int buflen). Doit être un StringBuilder sur le C#, côté avec suffisamment de Capacité.

OriginalL'auteur Rawat | 2015-10-07

  1. 4

    Comment à ce sujet (Remarque, il suppose une longueur correcte - vous devriez passer à la longueur de la mémoire tampon et d'éviter les débordements, etc):

    extern "C" __declspec(dllexport)  void  __cdecl getDataFromTable(char* tableName, char* buf)
{
    std::string st = getDataTableWise(statementObject, columnIndex);
    printf(st.c_str()); 

    strcpy(buf, st.c_str());
}

    Puis en C#:

    [DllImport("\\SD Card\\ISAPI1.dll")]
private static extern string getDataFromTable(byte[] tablename, byte[] buf);
static void Main(string[] args)
{
    byte[] buf = new byte[300];
    getDataFromTable(byteArray, buf);
    Console.writeLine(System.Text.Encoding.ASCII.GetString(buf));
}

    Remarque, ce n'est faire des hypothèses sur les encodages de caractères en C++ application n'étant PAS unicode. Si ils sont en unicode, utilisez UTF16 au lieu de l'ASCII.

    il fonctionne! merci
    ne devrait pas private static extern string getDataFromTable être private static extern void getDataFromTable ?

    OriginalL'auteur user3690202

  2. 4

    J'ai eu ce problème aussi, récemment, et même si j'ai une solution pour vous, malheureusement je ne peux pas vraiment l'expliquer. Je n'ai pas trouvé une bonne explication encore.

    mon code c++ pour récupérer une chaîne de caractères est:

    extern "C" { __declspec(dllexport) void __GetValue__(char* str, int strlen); }

    et mon code C#:

    [DllImport("MyDLL.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern void __GetValue__(StringBuilder str, int strlen);

    Donc, comme vous pouvez le voir, au lieu de retourner une valeur, vous pouvez fournir une chaîne de caractères (en utilisant StringBuilder) et de C++ remplir les données comme:

    void __GetValue__(char* str, int strlen) {
    std::string result = "Result";

    result = result.substr(0, strlen);

    std::copy(result.begin(), result.end(), str);
    str[std::min(strlen-1, (int)result.size())] = 0;
}

    Et pour l'intégralité du code C# à la demande de la chaîne:

    public String GetValue() {
    StringBuilder str = new StringBuilder(STRING_MAX_LENGTH);

    __GetValue__(str, STRING_MAX_LENGTH);

    return str.ToString();
}

    OriginalL'auteur Bas in het Veld

  3. 2

    L' .NET runtime utilise unicode (wchar_t) les chaînes de caractères, non ascii (char) donc cela nécessite quelques modifications.
    Il faut aussi tenir compte .NET n'a pas de moyen de les libérer d'une chaîne qui a été attribué par une application C/C++, afin d'avoir le tampon de pré-alloués et transmis à partir de C# est la seule façon de gérer cela sans fuites de mémoire ou pour le pire.

    OriginalL'auteur Valter Minute