C++ 回调 Function 到 C#

Question

I want to rewrite a Function from C++ to C#. I haven't any experience with C++ but that's what I already have written. The DLL Import with some functions already works.But this callback things struggles me. Pls help me:)

c++ code:

/* Structure for PBORCA_CompileEntryImport callback function. */
typedef struct pborca_comperr  
{
    INT     iLevel;                         
    LPTSTR   lpszMessageNumber;             
    LPTSTR   lpszMessageText;               
    UINT    iColumnNumber;                  
    UINT    iLineNumber;                   

} PBORCA_COMPERR, FAR *PPBORCA_COMPERR;


/* Prototype for PBORCA_CompileEntryImport callback function.  */            
typedef PBCALLBACK(void, *PBORCA_ERRPROC) ( PPBORCA_COMPERR, LPVOID );

my c# code:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
private struct PBORCA_COMPERR
{
    public int iLevel;                            
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
    public string lpszMessageNumber;               
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
    public string lpszMessageText;                  
    public int iColumnNumber;                       
    public int iLineNumber;                        
}

private delegate void PBORCA_CALLBACK(IntPtr pDirEntry, IntPtr lpUserData);

Answer 1

From what I understand there are a few possible ways you can do it. It will depend on what you require.

Option 1) Using IntPtr and Marshal.GetFunctionPointerForDelegate

// A template of the function you want other code to call
// Your calling convention may be different
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] // note calling convention
delegate void PBORCA_CALLBACK(IntPtr pDirEntry, IntPtr lpUserData);  

class Orca
{
    [DllImport("LibraryName.dll")]
    private static extern int PBORCA_CompileEntryImport(
        IntPtr hORCASession,
        ...
        long lEntrySyntaxBuffSize,
        IntPtr pCompErrorProc, // note the IntPtr
        IntPtr pUserData);

    // An implementation of the function delegate (this will be called)
    private static void StaticImpOfTheCallback(IntPtr pDirEntry, IntPtr lpUserData)
    {
        // write code here (Notice: I'm a static function)
    }

    // An implementation of the function delegate (this will be called)
    private void NonStaticImpOfTheCallback(IntPtr pDirEntry, IntPtr lpUserData)
    {
        // write code here (Notice: I'm not static)
    }

    // Create a delegate object which will link the callback function
    private PBORCA_CALLBACK staticCallbackDel = StaticImpOfTheCallback; 

    public void SomeCallingFunction()
    {
        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            Marshal.GetFunctionPointerForDelegate(staticCallbackDel), // Delegate to function ptr
            0);

        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            Marshal.GetFunctionPointerForDelegate(
                new PBORCA_CALLBACK(NonStaticImpOfTheCallback) // create a delegate instance
            ), // Delegate to function ptr
            0);
    }
}

Option 2 Using delegate directly in the definition

// A template of the function you want other code to call
// Your calling convention may be different
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] // note calling convention
delegate void PBORCA_CALLBACK(IntPtr pDirEntry, IntPtr lpUserData);  

class Orca
{
    [DllImport("LibraryName.dll")]
    private static extern int PBORCA_CompileEntryImport(
        IntPtr hORCASession,
        ...
        long lEntrySyntaxBuffSize,
        [MarshalAs(UnmanagedType.FunctionPtr)] // May or may not be needed
        PBORCA_CALLBACK pCompErrorProc, // note the use of the delegate
        IntPtr pUserData);

    // An implementation of the function delegate (this will be called)
    private static void StaticImpOfTheCallback(IntPtr pDirEntry, IntPtr lpUserData)
    {
        // write code here (Notice: I'm a static function)
    }

    // An implementation of the function delegate (this will be called)
    private static void NonStaticImpOfTheCallback(IntPtr pDirEntry, IntPtr lpUserData)
    {
        // write code here (Notice: I'm a static function)
    }

    // Create a delegate object which will link the callback function
    private PBORCA_CALLBACK staticCallbackDel = StaticImpOfTheCallback; 

    public void SomeCallingFunction()
    {
        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            staticCallbackDel, // no need to convert the delegate
            0);

        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            StaticImpOfTheCallback, // could call directly too.
            0);

        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            NonStaticImpOfTheCallback, // could call directly too.
            0);

        // same as above (I think)
        PBORCA_CompileEntryImport(
            0, 
            ... ,
            128, 
            new PBORCA_CALLBACK(NonStaticImpOfTheCallback), // more explicit
            0);
    }
}

These are most of the variations I can think of. One of them should suit you. If anything above is unclear I suggest you read some documentation on how delegates work in normal C# and experiment there before trying to use them in conjunction with C++ code. There are plenty of tutorial available for delegates online one of them should hopefully get the penny to drop if it hasn't already.

Good Luck