Call C/C++ CALLBACK DLL from C# (PInvoke? Wrapper class?)

[MyCrystalGift]

Hi,

I have an old C++ GUI Application CPPAPP.exe that calls a C DLL
library RULE.DLL through a C++ class wrapper LoadRule.CPP.

Now I need to call the C DLL RULE.DLL from C# GUI application
CSAPP.exe. I need help to convert LoadRule.CPP to a C++

BridgeDLL, and I need help on how to convert the call to the BridgeDLL
from C#.
//
*************** *************** *************** *************** *************** **********
//Rule.h: header file in C DLL RULE.DLL

#ifndef __RULE__
#define __RULE__
#ifdef __cplusplus
extern "C" {
#endif

typedef DWORD HRULE; /* Handle used in all calls */

typedef BOOL (CALLBACK* RULECALLBACK)(U INT nEvent, /* Event */
LPARAM lPar1, /*
Parameter 1 */
LPARAM lPar2, /*
Parameter 2 */
LPARAM dwExtra); /* Extra
data */
/*************** ***************/
/* Diagnostics data structure */
/*************** ***************/

typedef struct tagDIAGNOSTICS {
DWORD dwUsage; /* No. of times has beed used */
DWORD dwReserved0; /* For future use */
} DIAGNOSTICS;
typedef DIAGNOSTICS FAR * LPDIAGNOSTICS;

/*************** ********/
/* Function prototypes */
/*************** ********/

/*************** *************** *************** *************** *****/
/* Start new I/O session. */
/* Entry: hWnd = window handle of caller, could be NULL */
/* lpFn = address of callback handler */
/* lPar = extra info passed to callback function */
/* lphRule = where to copy session handle if open */
/* call was Successful. */
/* Exit: RULEERR_OK : connected OK */
/* RULEERR_MEMERR : memory allocation error */
/* RULEERR_UNKNOWN : unknown error */
/* RULEERR_NOCALLB ACKFNC : No callback function given */
/*************** *************** *************** *************** *****/

int WINAPI Rule_NewSession (HWND hWnd,
RULECALLBACK lpfnCallback,
LPARAM lPar,
HRULE FAR * lphRule);
int WINAPI Rule_EndSession (HRULE hRule);
int WINAPI Rule_ReadDiagno stics(HRULE hRule,LPDIAGNOS TICS lpDiag);
int WINAPI Rule_WriteDiagn ostics(HRULE hRule,LPDIAGNOS TICS lpDiag);
#ifdef __cplusplus
}
#endif

#endif // __RULE__

//
*************** *************** *************** *************** *************** **********
//LoadRule.h: C++ wrapper header file for DLL RULE.DLL

#ifdef __cplusplus
extern "C" {
#endif

/* Definitions for LoadRule.C module */

HINSTANCE LoadRule(LPTSTR lpszPath);
void UnloadRule(HINS TANCE hInst);

#ifdef __cplusplus
}
#endif
//
*************** *************** *************** *************** *************** **********
// LoadRule.cpp : C++ wrapper implementation file

#include "LoadRule.h "

typedef int (WINAPI *RULE_NewSessio n)(HWND hWnd,
RULECALLBACK lpfnCallback,
LPARAM lPar,
HRULE FAR * lphRule);

typedef int (WINAPI *RULE_EndSessio n)(HRULE hRule);
typedef int (WINAPI *RULE_ReadDiagn ostics)(HRULE hRule,LPDIAGNOS TICS
lpDiag);
typedef int (WINAPI *RULE_WriteDiag nostics)(HRULE hRule,LPDIAGNOS TICS
lpDiag);
static RULE_NewSession lpfnRule_NewSes sion;
static RULE_EndSession lpfnRule_EndSes sion;
static RULE_ReadDiagno stics lpfnRule_ReadDi agnostics;
static RULE_WriteDiagn ostics lpfnRule_WriteD iagnostics;

/* Local functions */

static BOOL LoadFunctionPoi nters(HINSTANCE hInst);
static void ClearFunctionPo inters(void);
HINSTANCE LoadRule(LPTSTR lpszPath)
{
HINSTANCE hInst;

hInst=LoadLibra ry(lpszPath);
if (!hInst) return hInst;

if (!LoadFunctionP ointers(hInst)) {
FreeLibrary(hIn st);
hInst=NULL;
}
return hInst;
}
void UnloadRule(HINS TANCE hInst)
{
FreeLibrary(hIn st);
ClearFunctionPo inters();
}

/*************** *************** ******* Local functions
*************** *************** **/

static BOOL LoadFunctionPoi nters(HINSTANCE hInst)
{
lpfnRule_NewSes sion = (RULE_NewSessio n)
GetProcAddress( hInst,TEXT("Rul e_NewSession")) ;
lpfnRule_EndSes sion = (RULE_EndSessio n)
GetProcAddress( hInst,TEXT("Rul e_EndSession")) ;

lpfnRule_ReadDi agnostics = (RULE_ReadDiagn ostics)
GetProcAddress( hInst,TEXT("Rul e_ReadDiagnosti cs"));
lpfnRule_WriteD iagnostics = (RULE_WriteDiag nostics)
GetProcAddress( hInst,TEXT("Rul e_WriteDiagnost ics"));

if (!lpfnRule_NewS ession ||
!lpfnRule_EndSe ssion ||
!lpfnRule_ReadD iagnostics ||
!lpfnRule_Write Diagnostics ){

ClearFunctionPo inters();
return FALSE;
}
return TRUE;
}

static void ClearFunctionPo inters(void)
{
lpfnRule_NewSes sion=NULL;
lpfnRule_EndSes sion=NULL;
lpfnRule_ReadDi agnostics=NULL;
lpfnRule_WriteD iagnostics=NULL ;

}

/*************** *************** ********* Rule.dll interface
*************** *************** *****/

int WINAPI Rule_NewSession (HWND hWnd,
RULECALLBACK lpfnCallback,
LPARAM lPar,
HRULE FAR * lphRule)
{
if (!lpfnRule_NewS ession) return RULEERR_BADHAND LE;
return (*lpfnRule_NewS ession)(hWnd,
lpfnCallback,
lPar,
lphRule);
}

int WINAPI Rule_EndSession (HRULE hRule)
{
if (!lpfnRule_EndS ession) return RULEERR_BADHAND LE;
return (*lpfnRule_EndS ession)(hRule);
}

int WINAPI Rule_ReadDiagno stics(HRULE hRule,LPDIAGNOS TICS lpDiag)
{
if (!lpfnRule_Read Diagnostics) return RULEERR_BADHAND LE;
return (*lpfnRule_Read Diagnostics)(hR ule,lpDiag);

}

int WINAPI Rule_WriteDiagn ostics(HRULE hRule,LPDIAGNOS TICS lpDiag)
{
if (!lpfnRule_Writ eDiagnostics) return RULEERR_BADHAND LE;
return (*lpfnRule_Writ eDiagnostics)(h Rule,lpDiag);
}


//
*************** *************** *************** *************** *************** **********
// CMyCEDlg.cpp: C++ application dialog

CMyCEDlg::CMyCE Dlg(CWnd* pParent /*=NULL*/)
: CDialog(CMyCEDl g::IDD, pParent)
{

// HWND m_hWnd;
// HINSTANCE m_hInstRule;
// HRULE hRule = NULL;

/* Load Rule.dll */
m_hInstRule = LoadRule(_T("\\ RULE.DLL"));
int iRet;
iRet = Rule_NewSession (m_hWnd, &MyCallback, (long)this,
&hRule);
if (iRet != RULEERR_OK)
{
UnloadRule(m_hI nstRule);
m_hInstRule = NULL;
}
else
{ // load DLL success!
// do things ....
}

}

BOOL CALLBACK CMyCEDlg::CBRul e(UINT nEvent, LPARAM lPar1, LPARAM
lPar2)
{
switch (nEvent)
{
case RULEEVENT_LINEO PENED:
//ShowMsgInfoText (_T("Line opened!"), (int) lPar1);
//bComStopped = FALSE;
break;

case RULEEVENT_LINEC LOSED:
//ShowMsgInfoText (_T("Line closed!"), (int) lPar1);
break;

case RULEEVENT_CONNE CTEDWITH:
//ShowMsgInfoText (_T("Connected with "), (int) lPar1);
break;

case RULEEVENT_OPERA TIONFAILED:
//ShowMsgInfoText (_T("Operation failed!"), (int) lPar1);
break;

}

return FALSE;
}

BOOL CALLBACK MyCallback(UINT nEvent, LPARAM lPar1, LPARAM lPar2,
LPARAM dwExtra)
{

if (dwExtra)
{
CMyCEDlg* Owner = (CMyCEDlg*) dwExtra;
return Owner->CBRule(nEven t, lPar1, lPar2);
}
else
return FALSE;
}

[MyCrystalGift]

Any MVP and gurus from Microsoft? Please help!

This is a very hard task involving CALLBACK functions from C library
DLL, Interop, HandleRef, PInvoke, wrapper class, DllImport Marshaling,
etc....

How to convert Rule_NewSession () from C++ to C#?

int iRet;
iRet = Rule_NewSession (m_hWnd, &MyCallback, (long)this, &hRule);

int WINAPI Rule_NewSession (HWND hWnd,
RULECALLBACK lpfnCallback,
LPARAM lPar,
HRULE FAR * lphRule)

Thanks.

[Ben Voigt]

<My***********@ gmail.comwrote in message
news:11******** *************@j 27g2000cwj.goog legroups.com...

Any MVP and gurus from Microsoft? Please help!

This is a very hard task involving CALLBACK functions from C library
DLL, Interop, HandleRef, PInvoke, wrapper class, DllImport Marshaling,
etc....

How to convert Rule_NewSession () from C++ to C#?

Just don't. Take your existing C++ wrapper class, change class to public
ref class, and compile with /clr to create a C++/CLI assembly that calls the
C dll and is usable from any .NET language.

The initial conversion should work pretty much that easily. After that, you
may need to go through and rewrite any wrapper functions that work with
strings, to accept System::String^ .

If you run into trouble compiling with /clr, try posting on the
microsoft.publi c.dotnet.langua ges.vc list