Tipps für die Verwendung einer C-Bibliothek von C#

Microsoft-Dokumentation für Marschall.GetFunctionPointerForDelegate hier:

"Wandelt ein Abgeordneter in einen Funktionszeiger, der callable von nicht verwaltetem code."

Für das Protokoll, ich habe die meisten der Weg, um zu bekommen, diese funktioniert, dann landete Sie ziehen an den entsprechenden C-Dateien in das C++ Projekt (da war ich im Kampf mit Kompatibilitätsproblemen im code, den ich gar nicht brauche).

Hier sind einige Tipps, die ich auf dem Weg abgeholt, die hilfreich sein können für Menschen geschieht, die auf diese Frage:

Marshalling-arrays

In C gibt es keinen Unterschied zwischen einem Zeiger auf ein double (double*) und ein array von doubles (double*). Wenn Sie kommen, um interop, Sie müssen in der Lage sein, um keine Verwechslungen. Ich brauchte das übergeben von arrays von double, so dass die Signatur könnte wie folgt Aussehen:

[DllImport(@"PathToDll")]
public static extern Foo(
    [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)[In] double[] x, 
    [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)[Out] double[] y, 
    int x_size, 
    int y_size)

C muss der zusätzliche Informationen, wie lang das array ist, die Sie zu Durchlaufen haben, als separate parameter. Die Anordnung muss auch wissen, wo diese Größe ist, so geben Sie die SizeParamIndex - gibt die Indexposition mit der Basis null, die Größe-parameter in der Liste Parameter.

Geben Sie auch die Richtung, in die das array soll übergeben werden. In diesem Beispiel x übergeben in Foo, die 'zurück' y.

Aufrufkonvention

Braucht man eigentlich nicht zu verstehen, die feineren details von dem, was dies bedeutet (in anderen Worten, ich nicht), Sie müssen nur wissen, dass unterschiedliche Aufrufkonventionen vorhanden ist, und, dass Sie müssen match auf beiden Seiten. Der C# - Standard ist StdCall, der C-Standard ist Cdecl. Dies bedeutet, dass Sie nur explizit angeben müssen, die Aufruf-Konvention, wenn es vom Standardwert abweicht, auf denen je Seite du stehst, es zu benutzen.

Dies ist besonders haarig im Falle eines Rückrufs. Wenn wir vorbei Rückruf C aus C# wir beabsichtigen für das callback aufgerufen wird, mit StdCall, aber wenn wir es übergeben, wir sind mit Cdecl. Diese Ergebnisse in der folgenden Signaturen (siehe diese Frage für den Zusammenhang):

//=======C-code======
//type signature of callback function
typedef int (__stdcall *FuncCallBack)(int, int);

void SetWrappedCallback(FuncCallBack); //here default = __cdecl

//======C# code======
public delegate int FuncCallBack(int a, int b);   //here default = StdCall 

[DllImport(@"PathToDll", CallingConvention = CallingConvention.Cdecl)]
private static extern void SetWrappedCallback(FuncCallBack func);

Verpackung der Rückruf

Offensichtlich, aber es war nicht sofort klar für mich:

int MyFunc(int a, int b)
{
   return a * b;
}
//...

FuncCallBack ptr = new FuncCallBack(MyFunc);
SetWrappedCallback(ptr);

.def-Datei

Alle Funktionen, die Sie verfügbar machen möchten, aus C++ - Projekt (zu DllImported), müssen Abbildung in der ModDef.def - Datei, deren Inhalt würde wie folgt Aussehen:

LIBRARY MyLibName
EXPORTS
    SetWrappedCallback  @1

extern "C"

Wenn Sie möchten, verwenden Sie C-Funktionen aus C++, müssen Sie deklarieren Sie als extern "C". Wenn Sie inklusive einer header-Datei von C-Funktionen, die Sie gehen wie folgt aus:

extern "C" {
  #include "C_declarations.h"
}

Vorkompilierte Header

Andere Sache, die ich tun musste, um zu vermeiden, Zusammenstellung Fehler war Right-click -> Properties -> C/C++ -> Precompiled Headers - und set - Precompiled header zu Vorkompilierte Header Nicht Verwenden für jedes 'C' - Datei.

Hier ist eine Möglichkeit, senden Sie eine MENGE von numerischen Daten, um Ihre C-Funktion über einen StringBuilder. Nur werfen Ihre zahlen in einem StringBuilder-Objekt, während die Einstellung Trennzeichen an die gewünschte Position et voilá:

class Program
    {  
        [DllImport("namEm.DLL", CallingConvention = CallingConvention.Cdecl, EntryPoint = "nameEm", 
            CharSet = CharSet.Ansi, BestFitMapping = false, ThrowOnUnmappableChar = true)]
        public static extern int nameEm([MarshalAs(UnmanagedType.LPStr)] StringBuilder str);
        static void Main(string[] args)
        {
            int m = 3;
            StringBuilder str = new StringBuilder();
            str.Append(String.Format("{0};", m));
            str.Append(String.Format("{0} {1:E4};", 5, 76.334E-3 ));
            str.Append(String.Format("{0} {1} {2} {3};", 65,45,23,12));
            m = nameEm(str);
        }
    }

- Und C-Seite, Holen die StringBuilder-Objekt als char*:

extern "C"
{
    __declspec(dllexport) int __cdecl nameEm(char* names)
    {
        int n1, n2, n3[4];
        char *token,
             *next_token2 = NULL,
             *next_token = NULL;
        float f;

        sscanf_s(strtok_s(names, ";", &next_token), "%d", &n2);
        sscanf_s(strtok_s(NULL, ";", &next_token), "%d %f", &n1, &f);
        //Observe the use of two different strtok-delimiters.
        //the ';' to pick the sequence of 4 integers,
        //and the space to split that same sequence into 4 integers.
        token = strtok_s(strtok_s(NULL, ";", &next_token)," ",&next_token2);
        for (int i=0; i < 4; i++)
        {
             sscanf_s(token,"%d", &n3[i]);
             token = strtok_s(NULL, " ",&next_token2);
        }    
        return 0;
    }
}