Wickeln Sie die native DLL für C#

Zuerst möchte ich anpassen, der Prototyp des nativen Funktion.

Da diese Funktion hat eine C-Schnittstelle, sollten Sie eine C-Typ für boolsche Variablen, nicht um eine C++ - Typ wie bool. Sie verwenden möchten, können Win32 ist BOOL geben.

Außerdem, wie es derzeit ist, Ihre Funktion ist anfällig für Pufferüberläufe: es ist besser, fügen Sie einen anderen parameter geben Sie die maximale Größe des Ziel - result string-Puffer.

Beachten Sie auch, dass eine weit verbreitete Aufrufkonvention für DLLs exportieren reines C-interface-Funktionen (wie viele Win32-API-Funktionen) ist __stdcall (nicht __cdecl). Ich würde verwenden, wie gut.

Zuletzt, da die ersten beiden Parameter sind Eingang Zeichenfolgen, die Sie verwenden möchten, können const deutlich zu machen und durchzusetzen, const-correctness.

So, ich würde der Prototyp die exportierte native Funktion wie diese:

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

Dann, auf der C# Seite, können Sie die folgenden 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);

Beachten Sie, dass für die Ausgabe einer Zeichenfolge, einer StringBuilder verwendet wird.

Beachten Sie auch, dass CharSet = CharSet.Ansi wird verwendet, um den Marschall C#'s Unicode UTF-16-Zeichenfolgen in ANSI (achten Sie auf die Tatsache, dass die Konvertierung verlustbehaftete - wenn Sie möchten, eine verlustfreie Konvertierung, verwenden Sie einfach wchar_t* Saiten auf C++ - Seite als auch).

Ich habe einen test mit einem einfachen C++ systemeigene DLL:

//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;
}

Genannt, der erfolgreich von den folgenden C# - Konsolenanwendung-code:

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());
        }
    }
}

warum Hinweis mit .Net-code marshalling mit DLLImport wie die folgenden

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

und dann können Sie die Funktion aufrufen, die als lokale Funktion wie die folgende

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

[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);

Den output-parameter einer char *, da C# strings sind unveränderlich. Rufen Sie die Methode (in einem unsicheren Kontext) so:

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

Es sei denn, die Ausgabe-parameter ist kein string sondern nur ein einzelnes Zeichen, in dem Fall kann man nur dazu:

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

Und Sie können es einfach verwenden, wie diese:

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