I've posted this to MSDN forums also, but maybe I can get feedback from
here too. Here it goes:
---
Hi all,

I've researched this matter for a couple of days now. I've seen samples
of code, got them to work on small scale samples. The problem is that
the final application is *critical* to our clients and our work. This
is why I need to be 110% sure that what I'm asking about is correct.

So, the problem is when the C++ DLL decides to callback the C# function
I registered. When the callback was registered, it used code like: new
MyCallback(SomeFunction), where MyCallback is a delegate type. Also,
I've taken care of holding a reference to the created delegate during
the period callbacks may 'strike'. But it is a known fact that this
object could be moved in memory by the garbage collector at a later
time. What happens then? Will the program crash? Does this even happen
(the delegate being moved around in memory)? In my small scale tests,
it looks like delegates are pinned in memory, but I doubt it. I need
some insight from MSFT about how the delegates are implemented
underneath. Maybe there are differences between regular delegates used
by C# only, and the ones that are marshaled to C++ DLLs.

I hope someone from MSFT can shed some light on this subject, I really
need be sure about this.

Best regards,
Cosmin Banu.

P.S. I need to know this for .NET v1.1 as well as v2.0. Primarily v1.1.