Envelopper DLL native pour C#

Je dois d'abord régler le prototype de ta fonction native.

Étant donné que cette fonction a un interface C, vous devez utiliser un type C pour les booléens, pas en C++, comme bool. Vous souhaiterez peut-être utiliser Win32 l' BOOL type.

En outre, comme c'est le cas actuellement, votre fonction est sujette à dépassements de la mémoire tampon: il est préférable d'ajouter un autre paramètre pour spécifier la taille maximale de la destination result tampon de chaîne.

Note également que la diffusion de l' convention d'appel pour les Dll de l'exportation pure C des fonctions de l'interface (comme beaucoup de fonctions de l'API Win32) est __stdcall (pas __cdecl). J'aimerais l'utiliser ainsi.

Dernier, depuis les deux premiers paramètres sont entrée chaînes de caractères, vous pouvez utiliser const de la rendre claire et appliquer la const-correctness.

Donc, je ferais le prototype de l'exportation natif de la fonction comme ceci:

extern "C" __declspec(dllexport) 
BOOL __stdcall NativeFunction(
    const char *in1, 
    const char *in2, 
    char *result, 
    int resultMaxSize);

Puis, sur le C#, côté, vous pouvez utiliser la suite de P/Invoke:

   [DllImport(
        "NativeDll.dll", 
        CharSet = CharSet.Ansi, 
        CallingConvention = CallingConvention.StdCall)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool NativeFunction(
        string in1,
        string in2,
        StringBuilder result, 
        int resultMaxSize);

Noter que pour la chaîne de sortie, un StringBuilder est utilisé.

Note également que CharSet = CharSet.Ansi est utilisé pour le maréchal de C#Unicode UTF-16 chaînes de caractères ANSI (payer l'attention sur le fait que la conversion est avec perte - si vous voulez un sans perte de conversion, il suffit d'utiliser wchar_t* des cordes sur le C++ côté).

J'ai fait un test avec un simple C++ DLL native:

//NativeDll.cpp

#include <string.h>
#include <windows.h>

extern "C" __declspec(dllexport) 
BOOL __stdcall NativeFunction(
    const char *in1, 
    const char *in2, 
    char *result, 
    int resultMaxSize)
{
    //Parameter check
    if (in1 == nullptr 
        || in2 == nullptr 
        || result == nullptr 
        || resultMaxSize <= 0)
        return FALSE;

    //result = in1 + in2
    strcpy_s(result, resultMaxSize, in1);
    strcat_s(result, resultMaxSize, in2);

    //All right
    return TRUE;
}

Et il est appelé avec succès par la suite C# console le code de l'application:

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace CSharpClient
{
    class Program
    {
        [DllImport(
            "NativeDll.dll", 
            CharSet = CharSet.Ansi, 
            CallingConvention = CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool NativeFunction(
            string in1,
            string in2,
            StringBuilder result, 
            int resultMaxSize);

        static void Main(string[] args)
        {
            var result = new StringBuilder(200);
            if (! NativeFunction("Hello", " world!", result, result.Capacity))
            {
                Console.WriteLine("Error.");
                return;
            }

            Console.WriteLine(result.ToString());
        }
    }
}

OriginalL'auteur Mr.C64

pourquoi la note à l'aide .Net code de marshaling à l'aide de DLLImport telles que les suivantes

[DllImport(@"C:\TestLib.dll")]
        public static extern void ProtectDocument(
            out [MarshalAs(UnmanagedType.LPStr)]string validToDate);

et puis vous pouvez appeler la fonction comme la fonction locale comme suit

string x=string.empty;
ProtectDocument(out x); 

OriginalL'auteur Saddam Abu Ghaida

[DllImport("MyLibrary.dll", EntryPoint = "NativeMethod")]
public static unsafe extern bool NativeMethod(
    [MarshalAs(UnmanagedType.LPStr)] string param1,
    [MarshalAs(UnmanagedType.LPStr)] string param2,
    [MarshalAs(UnmanagedType.LPStr)] char *param3);

Le paramètre de sortie doit être un char *, depuis C# les chaînes sont immuables. Vous appelez la méthode (dans un contexte dangereux) comme ceci:

char[] output = new char[100];
fixed (char *param = &output[0])
{
    NativeMethod("blahblah", "blahblah", param);
}

À moins que le paramètre de sortie n'est pas une chaîne mais un seul caractère, auquel cas il vous suffit de faire ceci:

[DllImport("MyLibrary.dll", EntryPoint = "NativeMethod")]
public static unsafe extern bool NativeMethod(
    [MarshalAs(UnmanagedType.LPStr)] string param1,
    [MarshalAs(UnmanagedType.LPStr)] string param2,
    out char param3);

Et vous pouvez simplement l'utiliser comme ceci:

char output;
NativeMethod("blahblah", "blahblah", out output);

OriginalL'auteur antonijn