Equivalent of C++'s reinterpret_cast in C#

Question

I wonder what's the equivalent of C++'s reinterpret_cast in C#!?

Here's my sample:

class Base
{
    protected int counter = 0;
}

class Foo : Base
{
    public int Counter
    {
        get { return counter; }
    }
}

Base b = new Base();
Foo f = b as Foo; // f will be null

I've got no objection why f will be null since it should be. But if it was C++ I could have written Foo f = reinterpret_cast<Foo>(b); and get what I wanted. What can I do to achieve the same in C#?

PS. I'm assuming that Base and Foo are consistent data-wise.

[UPDATE]

Here's a simple scenario where a reinterpret_cast could be helpful:

Consider writing an XXX-RPC library where you've got no control over the incoming parameters nor the signature of services to call. Your library is supposed to call the asked service with the given parameters. If C# supported reinterpret_cast I could simply reinterpret_cast the given parameters into the expected ones and call the service.

Answer 1

This works. And yes, it's as evil and as awesome as you can possibly imagine.

static unsafe TDest ReinterpretCast<TSource, TDest>(TSource source)
{
    var sourceRef = __makeref(source);
    var dest = default(TDest);
    var destRef = __makeref(dest);
    *(IntPtr*)&destRef = *(IntPtr*)&sourceRef;
    return __refvalue(destRef, TDest);
}

One thing to note is that if you're casting a T[] to and U[]:

• If T is bigger than U, the bounds-checking will prevent you from accessing the U elements past the original length of the T[]
• If T is smaller than U, the bounds-checking will let you read past the last element (effectively its a buffer overrun vulnerability)