Inheriting From a Native C++ Class in C#

Inheriting From a Native C++ Class in C#

Rate This
  • Comments 26

Hi, this is Jim Springfield, an architect on the Visual C++ team.  I have blogged in the past about our IDE and Intellisense work.  I am still heavily focused on that and we are working hard to deliver an improved experience, but this post is about a completely different topic.  A few months ago, I started thinking about how to access C++ classes from managed code and came up with this technique, which I haven’t seen mentioned anywhere else.

There are many ways that native code and managed code can interact and call each other.  If you have native code that you want to call from C# you have several choices depending on the nature of the API.  If you have a flat “C” API, you can use P/Invoke to directly call the API.  If the native code is exposed using COM, the CLR’s COM Interop can provide access.  If you have a C++ class, you could go add COM support, or write a custom wrapper using C++/CLI and expose a new managed class.

I really wanted something more direct than these.  Initially, I was just trying to see if I could call a native C++ class from C#, but as I started playing with it, I realized that I could actually “inherit” from the native class.  I put “inherit” in quotes, because you could make an argument that it isn’t truly inheritance, but I will let the reader make the final decision.

Let’s say I have a C++ class exposed from a DLL that I want to consume in C#.  The class looks like the following.

class __declspec(dllexport) CSimpleClass {

public:

      int value;

      CSimpleClass(int value) : value(value)

      {

      }

      ~CSimpleClass()

      {

            printf("~CSimpleClass\n");

      }

      void M1()

      {

            printf("C++/CSimpleClass::M1()\n");

            V0();

            V1(value);

            V2();

      }

      virtual void V0()

      {

            printf("C++/CSimpleClass::V0()\n");

      }

      virtual void V1(int x)

      {

            printf("C++/CSimpleClass::V1(%d)\n", x);

      }

      virtual void V2()

      {

            printf("C++/CSimpleClass::V2()\n", value);

      }

};

 

The __declspec(dllexport) means that the class is exported from the DLL.  What this really means is that all of the class methods are exported from the DLL.  If I look at the list of exports using dumpbin.exe or depends.exe, I see the following list of exports.

??0CSimpleClass@@QAE@ABV0@@Z
??0CSimpleClass@@QAE@H@Z
??1CSimpleClass@@QAE@XZ
??4CSimpleClass@@QAEAAV0@ABV0@@Z
??_7CSimpleClass@@6B@
?M1@CSimpleClass@@QAEXXZ
?V0@CSimpleClass@@UAEXXZ
?V1@CSimpleClass@@UAEXH@Z
?V2@CSimpleClass@@UAEXXZ

These are decorated (i.e. “mangled”) names.  For most of these, you can probably guess what the name is actually referring to. 

(Note: Name mangling may change between versions of C++ and mangling is different between x86, x64, and Itanium platforms.  The example here works on both VS2008 and the CTP release of VS2010.)

There is a nifty tool called undname.exe that ships with Visual Studio, which can take a mangled name and undecorate it.  Running it on each of the names above gives the corresponding output.

public: __thiscall CSimpleClass::CSimpleClass(int)

public: __thiscall CSimpleClass::~CSimpleClass(void)

public: class CSimpleClass & __thiscall CSimpleClass::operator=(class CSimpleClass const &)

const CSimpleClass::`vftable'

public: void __thiscall CSimpleClass::M1(void)

public: virtual void __thiscall CSimpleClass::V0(void)

public: virtual void __thiscall CSimpleClass::V1(int)

public: virtual void __thiscall CSimpleClass::V2(void)

 

Other than the methods we explicitly defined, there is also a compiler generated assignment operator and a reference to the vtable for this class.  OK, so I know that using P/Invoke, C# can call into native DLL entry points, and I just happen to have a list of native entry points. 

First, however, we need to define a structure in C# that corresponds to the native class.  Our native class only has one field: an int.  However, it does have virtual methods, so there is also a vtable pointer at the beginning of the class. 

(Note: I am only dealing with single inheritance here.  With multiple inheritance, there are multiple vtables and vtable pointers.)

[StructLayout(LayoutKind.Sequential, Pack = 4)]

public unsafe struct __CSimpleClass

{

public IntPtr* _vtable;

public int value;

}

 

Next, I am going to define a C# class that wraps the native class and mimics it.  I want to expose synchronous destruction, so the C# equivalent of that is implementing IDisposable, which I do here.  I also create a matching constructor and the “M1” method of CSimpleClass.  I use “DllImport” to specify the DLL name, entrypoint, and calling convention.  The “ThisCall” convention is the default for C++ member functions.

(Note: to be safer, I should explicitly specify calling conventions and structure packing in my native code, but that is left out for brevity.  If they aren’t explicitly specified, compiler options can change the defaults.)

There are calls in the code below to Memory.Alloc and Memory.Free.  These were implemented by me and just forward to HeapAlloc/Free in kernel32.dll.

public unsafe class CSimpleClass : IDisposable

{

    private __CSimpleClass* _cpp;

 

    // CSimpleClass constructor and destructor

    [DllImport("cppexp.dll", EntryPoint = "??0CSimpleClass@@QAE@H@Z", CallingConvention = CallingConvention.ThisCall)]

    private static extern int _CSimpleClass_Constructor(__CSimpleClass* ths, int value);

    [DllImport("cppexp.dll", EntryPoint = "??1CSimpleClass@@QAE@XZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern int _CSimpleClass_Destructor(__CSimpleClass* ths);

 

    //      void M1();

    [DllImport("cppexp.dll", EntryPoint = "?M1@CSimpleClass@@QAEXXZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern void _M1(__CSimpleClass* ths);

 

    public CSimpleClass(int value)

    {

        //Allocate storage for object

        _cpp = (__CSimpleClass*)Memory.Alloc(sizeof(__CSimpleClass));

        //Call constructor

        _CSimpleClass_Constructor(_cpp, value);

    }

    public void Dispose()

    {

        //call destructor

        _CSimpleClass_Destructor(_cpp);

        //release memory

        Memory.Free(_cpp);

        _cpp = null;

    }

    public void M1()

    {

        _M1(_cpp);

    }

}

 

So, at this point I can create a CSimpleClass in C# and call the “M1” method like this.  The “using” statement defines a scope.  At the end of the scope, Dispose() will automatically be called on sc.

static void Main(string[] args)

{

    CSimpleClass sc = new CSimpleClass(10);

    using (sc)

    {

        //M1 calls all of the virtual functions V0,V1,V2

        sc.M1();

    }

}

 

Running this code gives me the following output on the console.  M1 calls each of the virtual functions V0, V1, and V2.

C++/CSimpleClass::M1()
C++/CSimpleClass::V0()
C++/CSimpleClass::V1(10)
C++/CSimpleClass::V2()

OK, this is pretty cool, right?  That’s what I was thinking anyway.  A couple of days later, I picked up this code again and started thinking that it would be really cool if I could override a virtual function.  I’ve already got the vtable pointer in my __CSimpleClass structure.  I know that the vtable pointer points to an array of function pointers, at least in the simple single inheritance case.  (Multiple inheritance and virtual inheritance can add some significant wrinkles to this.)  If I can change a function in the vtable, then I’ve overridden it.  The vtables themselves are shared by all instances of a class, so I can’t just go pound a slot in the vtable with my own function pointer.  I need to actually create my own vtable. 

I need to construct an array of native pointers to my virtual method overrides and replace the vtable pointer with a pointer to my vtable.  As it turns out, the .Net libraries provides a mechanism to implement callbacks from native code.  This is Marshal.GetFunctionPointerForDelegate, and it works just fine for our needs. 

First of all, we need to use DllImport to get access to the virtual functions we are overriding.  This is just like what we did to access the M1 method above.   The example below only shows the code for V1, but we actually need it for V0 and V2 as well.  I chose V1 for the example as it is the only virtual that takes a parameter.  The others take no arguments.

[DllImport("cppexp.dll", EntryPoint = "?V1@CSimpleClass@@UAEXH@Z", CallingConvention = CallingConvention.ThisCall)]

private static extern void _V1(__CSimpleClass* ths, int i);

 

Now, we need to implement our override in the managed version of CSimpleClass.  It simple forwards to the _V1 that we defined above, which is a direct call to the native version in cppexp.dll.

public virtual void V1(int i)

{

      _V1(_cpp, i);

}

 

The tricky part is to get our new virtual function V1 into the vtable.  This can be done by creating a delegate in our class.  We declare a delegate and specify an instance of it.  Again, we need to do this for V0 and V2 as well.

public delegate void V1_Delegate(int i);
public V1_Delegate _v1_Delegate;

In our C# CSimpleClass constructor, we need to create the delegates, use Marshal.GetFunctionPointerForDelegate for each delegate, put them into an array, and override the vtable pointer in the native class.  Here is what the final class looks like.  We remember the old vtable pointer as well, so that we can reset it in the Dispose method to the old value.  C++ differs from C# in this regard in that as an object is constructed, its vtable pointer will change to match the level in the inheritance.  If you look closely, you will see two other helper functions that I’ve defined:  InitVtable and ResetVtable.  InitVtable does the work of copying the function pointers from the managed array into some native memory and then patching the vtable of the object.  ResetVtable puts the old vtable pointer back and frees the memory of the created vtable.  In C++, a single copy of the vtable is shared by all instances of a class, but here we create a unique vtable for each instance.  This is needed as the delegates encompass the actual managed object itself rather than just a pointer to a method that takes a “this” pointer.  We don’t actually use the “this” pointer that is passed to us from native code as the delegate implicitly knows the managed object and the managed object contains a pointer to the native object.

public unsafe class CSimpleClass : IDisposable

{

    private __CSimpleClass* _cpp;

    private IntPtr* _oldvtbl;

 

    private void InitVtable(__CSimpleClass* ths, IntPtr[] arr, int len)

    {

        IntPtr* newvtable = (IntPtr*)Memory.Alloc(len * sizeof(IntPtr));

        for (int i = 0; i < len; i++)

            newvtable[i] = arr[i];

        _oldvtbl = ths->_vtable;

        ths->_vtable = newvtable;

    }

 

    private void ResetVtable(__CSimpleClass* ths)

    {

        IntPtr* oldvtbl = ths->_vtable;

        ths->_vtable = _oldvtbl;

        Memory.Free(oldvtbl);

    }

    // CSimpleClass constructor and destructor

    [DllImport("cppexp.dll", EntryPoint = "??0CSimpleClass@@QAE@H@Z", CallingConvention = CallingConvention.ThisCall)]

    private static extern int _CSimpleClass_Constructor(__CSimpleClass* ths, int value);

    [DllImport("cppexp.dll", EntryPoint = "??1CSimpleClass@@QAE@XZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern int _CSimpleClass_Destructor(__CSimpleClass* ths);

 

    //      void M1();

    //      virtual void V0();

    //  virtual void V1(int x);

    //  virtual void V2();

    [DllImport("cppexp.dll", EntryPoint = "?M1@CSimpleClass@@QAEXXZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern void _M1(__CSimpleClass* ths);

    [DllImport("cppexp.dll", EntryPoint = "?V0@CSimpleClass@@UAEXXZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern void _V0(__CSimpleClass* ths);

    [DllImport("cppexp.dll", EntryPoint = "?V1@CSimpleClass@@UAEXH@Z", CallingConvention = CallingConvention.ThisCall)]

    private static extern void _V1(__CSimpleClass* ths, int i);

    [DllImport("cppexp.dll", EntryPoint = "?V2@CSimpleClass@@UAEXXZ", CallingConvention = CallingConvention.ThisCall)]

    private static extern void _V2(__CSimpleClass* ths);

 

    public delegate void V0_Delegate();

    public delegate void V1_Delegate(int i);

    public delegate void V2_Delegate();

 

    public V0_Delegate _v0_Delegate;

    public V1_Delegate _v1_Delegate;

    public V2_Delegate _v2_Delegate;

 

    public CSimpleClass(int value)

    {

        //Allocate storage for object

        _cpp = (__CSimpleClass*)Memory.Alloc(sizeof(__CSimpleClass));

        //Call constructor

        _CSimpleClass_Constructor(_cpp, value);

        //Create delegates for the virtual functions

        _v0_Delegate = new V0_Delegate(V0);

        _v1_Delegate = new V1_Delegate(V1);

        _v2_Delegate = new V2_Delegate(V2);

        IntPtr[] arr = new IntPtr[3];

        arr[0] = Marshal.GetFunctionPointerForDelegate(_v0_Delegate);

        arr[1] = Marshal.GetFunctionPointerForDelegate(_v1_Delegate);

        arr[2] = Marshal.GetFunctionPointerForDelegate(_v2_Delegate);

        //Create a new vtable and replace it in the object

        InitVtable(_cpp, arr, 3);

    }

    public void Dispose()

    {

        //reset old vtable pointer

        ResetVtable(_cpp);

        //call destructor

        _CSimpleClass_Destructor(_cpp);

        //release memory

        Memory.Free(_cpp);

        _cpp = null;

    }

    public void M1()

    {

        _M1(_cpp);

    }

    public virtual void V0()

    {

        _V0(_cpp);

    }

    public virtual void V1(int i)

    {

        _V1(_cpp, i);

    }

    public virtual void V2()

    {

        _V2(_cpp);

    }

}

 

We have a managed CSimpleClass with virtual methods that can be overridden in a derived class.  If we create a new C# class that inherits from CSimpleClass, we can override any virtual functions.   In CSimpleClassEx, we are overriding V2 and writing out some text.

class CSimpleClassEx : CSimpleClass

{

    public CSimpleClassEx(int value)

        : base(value)

    {

    }

    public override void V2()

    {

        Console.WriteLine("C#/CSimpleClassEx.V2()");

    }

}

 

If we create in instance of CSimpleClassEx and call M1, we now get the following output.

C++/CSimpleClass::M1()
C++/CSimpleClass::V0()
C++/CSimpleClass::V1(10)
C#/CSimpleClassEx.V2()

So, what do you think?  Is it really inheritance?  Is it just a stupid trick?  It definitely requires a lot of manual code writing to make this work, but let’s do some blue sky thinking for a bit.  It is easy to get a list of exports from the DLL, and the mangled names encapsulate a good bit of information including calling convention, name, return type, parameters.  I could probably write a tool to generate this.  And if I have the PDB, I could get the structure of the class including data members, structure packing, etc.

Now, back to working on C++ IDE performance and scalability for Visual Studio 2010.

  • Waste of electrons. Fix the IDE. Fix the motherflipping IDE!!!!

  • > Now, back to working on C++ IDE performance and scalability for Visual Studio 2010.

    Yes, you'd better do that :)

    Anyway, nice post but it would be better to have a tool that do the procedure automatically.

    Thanks,

  • Wow... Nice.

    Someone should write a tool to automate it.

  • Could this approach work with MFC dll's?

  • Definitely hot ! I have had a few instances of dealing with large existing c++ bases I would love to slowly upgrade to something somewhat modern like c# ;)

  • Doesn't GetFunctionPointerForDelegate() create a __stdcall function pointer?

    I understand __thiscall is just like __stdcall but with the "this" passed on ECX. This means the this pointer is not just being ignored, it simply cannot be accessed unless you can write some asm code to read it or otherwise make GetFunctionPointerForDelegate() return a __thiscall pointer.

  • Very interesting and very motivating article! Interop is hot discussion topic, since nobody wants to rewrite old (really old) code bases. It's nice to have one more ace in the hole!

    Is there any performance issues? Is there any performance comparison between P/Invoke and C++ Interop?

    Thanks...

  • A tool to automate it exists - it's called C++/CLI ;)

  • C++/CLI is only viable for MS .Net, not Mono. This could enable cross platform wrappers of C++ classes? Pretty cool technique anyway.

  • This is really cool! Not that useful, but still very cool and interesting. I would use your article, if was a teacher and was teaching some advanced [object-oriented | compiler construction | component base systems] class at the university.

  • Good catch JPV.

    Regarding __stdcall vs __thiscall on the delegate.  I could have specified

           [UnmanagedFunctionPointer(CallingConvention.ThisCall)]

    on the delegate and then added a __CSimpleClass* as the first argument on each of my V0, V1, and V2.  I didn't want this as the signature of my virtual functions, so I would have had to create another set of intermediate functions with the this pointer and that forwards to the virtual one without it.  Because of how thiscall works, I was able to avoid it and the this pointer in ECX is ignored.

  • This technique should work with MFC.  I thought about trying to do this as the example, but it would have been harder to understand the concepts.  Just creating and invoking a method on an MFC class would be simpler than trying to inherit from it.  That would be my first step.

    Regarding performance.  This really is just P/Invoke, I'm just showing how to map it onto C++ classes.  It is hard to make a blanket statement about which is faster.  It really depends on the scenario.

  • Can this all be handled automatically? I get all the theory, I just don't want to muck around with it. I'd rather use c++/cli if I had to write anything by hand.

  • How about typeinfo, it was said related with vtable.

  • what about typeinfo?  It was said having some relation with vtable too

Page 1 of 2 (26 items) 12