C# delegate per callback C++

Question

Penso di aver praticamente capito come scrivere i delegati C# per i callback, ma questo mi confonde. Il C++ definizione è la seguente:

typedef int (__stdcall* Callback)(
long lCode, 
long lParamSize, 
void* pParam 
); 

e il mio C# approccio sarebbe:

unsafe delegate int CallbackDelegate (int lCode, int lParamSize, IntPtr pParam); 

Anche se questo sembra essere corretto, perché ricevo un errore di PInvokeStackInbalance, il che significa che la mia definizione del delegato è sbagliato.

Il resto dei parametri della funzione sono stringhe o int, il che significa che non possono causare l'errore, e se ho appena passato un IntPtr.Zero invece del delegato (il che significherebbe che sto puntando a un non- funzione di callback esistente) Ricevo un errore di AccessViolation, che ha anche un senso.

Cosa sto sbagliando?

EDIT: la funzione

La piena C++ è:

int 
__stdcall 
_Initialize (
const char*   FileName, 
Callback   cbFunction, 
int     Code, 
const char*   Name, 
unsigned int  Option, 
unsigned int  Option2 
); 

mio C# versioni:

[DllImport("MyDll.dll", CallingConvention = CallingConvention.StdCall)] 
public static extern int _Initialize (string FileName, CallbackDelegate cbFunction, int Code, string Name, uint Options, uint Options2); 

La funzione è (per la prova) appena chiamato all'interno della routine principale un'applicazione console:

static void Main(string[] args) 
{ 
    CallbackDelegate del = new CallbackDelegate(onCallback); 

    Console.Write(_Initialize("SomeFile.dat", del, 1000, "", 0, 4)); 
    Console.Read(); 
} 

dove onCallback è questo:

static int onCallback(int lCode, int lParamSize, IntPtr pParam) 
{ 
    return 0; 
} 

ottengo l'errore PInvokeStackInbalance nella riga in cui chiamo _Initialize, se mi passa un IntPtr.Zero invece del delegato, e cambiare la definizione della funzione di IntPtr anziché CallbackDelegate poi Ottengo un AccessViolationException.

Answer 1

A .NET long è 64 bit. Un C++ long può essere solo 32 bit. Verifica con il compilatore C++ che ha compilato la definizione di quale dimensione sono i long s.

Answer 2

[UnmanagedFunctionPointerAttribute(CallingConvention.StdCall)] 
unsafe delegate int CallbackDelegate (int lCode, int lParamSize, IntPtr pParam); 

Se .NET assume cdecl invece di stdcall, lo stack verrà sicuramente protetto.

Answer 3

Ho aggiunto il codice al mio progetto corrente dove sto facendo un sacco di C#/C++ in VS2012. E mentre odio usare "ha funzionato sulla mia macchina", ha funzionato bene per me. Il codice che ho eseguito è elencato di seguito solo per illustrare che non ho apportato modifiche fondamentali.

Il mio suggerimento è quello di creare una nuova dll nativa con una funzione di stub per _Inizializzare come di seguito e vedere se funziona quando è possibile controllare entrambi i lati dell'interfaccia. Se funziona, ma la vera dll non lo fa, si tratta di impostazioni del compilatore sul lato nativo o di un bug sul lato nativo che si muove in pila.

extern "C" { 

    typedef int (__stdcall* Callback)(long lCode,long lParamSize,void* pParam); 

    TRADITIONALDLL_API int __stdcall _Initialize (const char* FileName,Callback cbFunction, int     Code, 
           const char*   Name,unsigned int  Option,unsigned int  Option2) 
    { 
     cbFunction(0, 0, nullptr); 
     return 0; 
    } 
} 

Sul lato C#, ho aggiunto le dichiarazioni alla mia classe di interfaccia:

public delegate int CallbackDelegate(int lCode, int lParamSize, IntPtr pParam); 

[DllImport("XXX.dll", CallingConvention = CallingConvention.StdCall)] 
public static extern int _Initialize(string FileName, CallbackDelegate cbFunction, int Code, string Name, uint Options, uint Options2); 

E poi nel mio principale:

private int onCallback(int lCode, int lParamSize, IntPtr pParam) 
{ 
     return 0; 
} 
XXXInterface.CallbackDelegate del = new XXXInterface.CallbackDelegate(onCallback); 

Console.Write(XXXInterface._Initialize("SomeFile.dat", del, 1000, "", 0, 4));