Click here to Skip to main content
12,689,947 members (26,533 online)
Click here to Skip to main content
Add your own
alternative version


37 bookmarked

Implementing Callback functions using IJW (avoiding DllImport)

, 13 Jul 2002
Rate this:
Please Sign up or sign in to vote.
Shows how you can call native API functions that require callbacks using IJW, and without the use of DllImport attribute. The technique allows you to pass a delegate as the callback function just as in the MS recommended manner except, I show you how to do this without the ugly DllImport attribute.


This whole business started one day when there was a post in the Microsoft newsgroup where someone was complaining that he was having trouble using <code lang=mc++>EnumWindows from Managed C++. He stated very firmly that he did not want to use the <code lang=mc++>DllImport attribute. This got me interested naturally, and I thought I could try and help him out. To my utter disappointment I found that I was having trouble too. The issue was that <code lang=mc++>EnumWindows took as it's first argument a callback function. All my searches on MSDN and google took me to solutions that showed how to do this using the <code lang=mc++>DllImport attribute. The technique suggested was simple. We are to declare a <code lang=mc++>__delegate object identical to the callback function. Now we are to use <code lang=mc++>DllImport to define <code lang=mc++>EnumWindows so that it takes as first argument our <code lang=mc++> __delegate type. Now we can simply write our callback function as a member of a managed class and pass this function to <code lang=mc++>EnumWindows.

<pre lang=mc++>//declare our delegate __delegate bool CallBack(IntPtr hwnd, IntPtr lParam); ... //ugghhhhhhh!!!! so uglyyyyyy!!! [DllImport("user32")] extern "C" int EnumWindows(CallBack* x, int y); ... //create the delegate CallBack* cb = new CallBack(0, &SomeClass::SomeMatchingMethod); //call the function EnumWindows(cb, 0);

The problem

All this is well and good, but it was beginning to get annoying. My problem was that whatever I did I couldn't get the callback function to work. Obviously I couldn't pass a delegate directly because when we use IJW, the native API functions expect native arguments and not managed arguments. I even tried something as silly as casting a delegate object to a <code lang=mc++>WNDENUMPROC and as you might have guessed failed thoroughly. I also tried passing both static and instance members of managed classes as the callback function, but I kept getting run time exceptions about <code lang=mc++>NULL references and objects. This was really disappointing to say the least.

That's when I got a huge boost from Richard Grimes who is a Microsoft MVP, and who has written several quality books on Microsoft programming technologies. His latest book is on using the managed extensions to program with VC++ .NET. In reply to my query about calling <code lang=mc++>EnumWindows using IJW, he replied to me and the reply included a sample code snippet from his latest book, but unfortunately he used <code lang=mc++>DllImport. I replied back saying that I wasn't looking for <code lang=mc++>DllImport and I must say my exasperation must have reflected poorly in my reply. Because Richard's answer was a little crispy too to begin with. But he gave me my first clue as to why I was going the wrong direction. He explained to me how managed class members use the <code lang=mc++>__clrcall calling convention and how unmanaged callback functions use the <code lang=mc++>__stdcall calling convention  In fact when I took a closer look at the compiler warnings, I was shocked to find a message that said that I was trying to attempt a redefinition of calling convention from <code lang=mc++>__clrcall to <code lang=mc++>__stdcall  which is not possible and was therefore being ignored. That's when I realized that I simply had to give up trying to use a managed class member method as my callback.

The solution

Richard's final answer was an emphatic NO. But I badly wanted to figure out a way by which a managed class can pass a delegate as the callback function. That's when this idea hit me out of the blue. Inner classes. We could use inner classes, see! All we had to do was to have an <code lang=mc++>__gc class with an inner <code lang=mc++>__nogc class and the outside managed class will wrap the inner unmanaged class and expose it to the outside world. The outer class has a delegate that acts as the managed callback. The inner <code lang=mc++>__nogc class has a native <code lang=mc++>__stdcall method as the callback function. This callback function will invoke the managed delegate each time it gets called. Thus we simulate a managed callback mechanism here. I have commented the code in vital areas so that you can understand this better.

<pre lang=mc++>__gc class CEnumWindows //outer class { private: __nogc class _CEnumWindows //inner class { private: /* This is a native function that follows the */ /* __stdcall calling convention that's required */ static BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM) { // We need to get the managed callback // up for each instance that our callback // gets called. So we get a pointer to // the current instance of the outer class // and invoke the delegate that is holding // the managed callback method that the // callee code has passed to us CEnumWindows* pew = CEnumWindows::GetClass(); pew->m_EnumProc->Invoke(hwnd, NULL); return TRUE; } public: void StartFinding() { EnumWindows((WNDENUMPROC)_CEnumWindows::EnumWindowsProc,NULL); } }; private: _CEnumWindows* m_ew; public: __delegate bool EnumProc(IntPtr hwnd, IntPtr lParam); static CEnumWindows* GetClass() { //This for the unmanaged class to use //when it needs a pointer to the managed class return m_pclass; } static CEnumWindows* m_pclass=NULL; CEnumWindows() { m_pclass = this; m_ew = new _CEnumWindows(); //unmanaged heap } ~CEnumWindows() { // we need to delete the object manually // as is is on the unmanaged heap delete m_ew; } void StartFinding() { m_ew->StartFinding(); } EnumProc* m_EnumProc; };

Now we can use this from any managed class and pass any managed class member function as the callback function. In the example below, I create a new instance of <code lang=mc++>CEnumWindows which is the outer class. Then I associate a managed function from one of my classes to the delegate member of the <code lang=mc++>CEnumWindows object. Alright, alright, I know that using a public delegate member is not a proper way to do this, but I am only trying to demonstrate how this is done. Put this in a property if you want to, or write a function that'll do this for you.

<pre lang=mc++>CEnumWindows* p = new CEnumWindows(); p->m_EnumProc = new CEnumWindows::EnumProc(this,&NForm::EWHandler); p->StartFinding();


For my own whimsical reasons I am a big fan of using IJW which I feel is a lot more natural for a C++ programmer than the use of weird looking attributes that makes your code look like C# or VB .NET. I don't have anything against other languages but I prefer my C++ code too look like C++ and not like some kind of ugly mutation of other subjectively inferior languages. Anyway thanks goes to Richard Grimes for pointing me in the correct direction. Those of you who are interested in his new book on using the managed extensions can go to this link. Programming with Managed Extensions for Microsoft® Visual C++® .NET (Microsoft Press)


This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


About the Author

Nish Nishant
United States United States
Nish Nishant is a Software Architect/Consultant based out of Columbus, Ohio. He has over 16 years of software industry experience in various roles including Lead Software Architect, Principal Software Engineer, and Product Manager. Nish is a recipient of the annual Microsoft Visual C++ MVP Award since 2002 (14 consecutive awards as of 2015).

Nish is an industry acknowledged expert in the Microsoft technology stack. He authored
C++/CLI in Action for Manning Publications in 2005, and had previously co-authored
Extending MFC Applications with the .NET Framework for Addison Wesley in 2003. In addition, he has over 140 published technology articles on and another 250+ blog articles on his
WordPress blog. Nish is vastly experienced in team management, mentoring teams, and directing all stages of software development.

Contact Nish : You can reach Nish on his google email id voidnish.

Website and Blog

You may also be interested in...


Comments and Discussions

QuestionWhy? Pin
hanifku9-Apr-06 15:02
memberhanifku9-Apr-06 15:02 
AnswerRe: Why? Pin
PunCha20-Nov-06 16:21
memberPunCha20-Nov-06 16:21 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.170113.4 | Last Updated 14 Jul 2002
Article Copyright 2002 by Nish Nishant
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid