{"id":4713,"date":"2008-12-08T15:29:00","date_gmt":"2008-12-08T15:29:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2008\/12\/08\/inheriting-from-a-native-c-class-in-c\/"},"modified":"2019-02-18T18:53:57","modified_gmt":"2019-02-18T18:53:57","slug":"inheriting-from-a-native-c-class-in-c","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/inheriting-from-a-native-c-class-in-c\/","title":{"rendered":"Inheriting From a Native C++ Class in C#"},"content":{"rendered":"

Hi, this is Jim Springfield, an architect on the Visual C++ team.  <\/span>I have blogged in the past about our IDE and Intellisense work.  <\/span>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.  <\/span>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.<\/font><\/p>\n

There are many ways that native code and managed code can interact and call each other.  <\/span>If you have native code that you want to call from C# you have several choices depending on the nature of the API.  <\/span>If you have a flat “C” API, you can use P\/Invoke to directly call the API.  <\/span>If the native code is exposed using COM, the CLR’s COM Interop can provide access.  <\/span>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.<\/font><\/p>\n

I really wanted something more direct than these.  <\/span>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.  <\/span>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.<\/font><\/p>\n

Let’s say I have a C++ class exposed from a DLL that I want to consume in C#.  <\/span>The class looks like the following.<\/font><\/p>\n

class<\/span> __declspec<\/span>(dllexport<\/span>) CSimpleClass {<\/p>\n

<\/span><\/p>\n

public<\/span>:<\/p>\n

<\/span><\/p>\n

      <\/span>int<\/span> value;<\/p>\n

<\/span><\/p>\n

      <\/span>CSimpleClass(int<\/span> value) : value(value)<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

      <\/span>~CSimpleClass()<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

            <\/span>printf(“~CSimpleClassn”<\/span>);<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

      <\/span>void<\/span> M1()<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

            <\/span>printf(“C++\/CSimpleClass::M1()n”<\/span>);<\/p>\n

<\/span><\/p>\n

            <\/span>V0();<\/p>\n

<\/span><\/p>\n

            <\/span>V1(value);<\/p>\n

<\/span><\/p>\n

            <\/span>V2();<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

      <\/span>virtual<\/span> void<\/span> V0()<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

            <\/span>printf(“C++\/CSimpleClass::V0()n”<\/span>);<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

      <\/span>virtual<\/span> void<\/span> V1(int<\/span> x)<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

            <\/span>printf(“C++\/CSimpleClass::V1(%d)n”<\/span>, x);<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

      <\/span>virtual<\/span> void<\/span> V2()<\/p>\n

<\/span><\/p>\n

      <\/span>{<\/p>\n

<\/span><\/p>\n

            <\/span>printf(“C++\/CSimpleClass::V2()n”<\/span>, value);<\/p>\n

<\/span><\/p>\n

      <\/span>}<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

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

??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<\/font><\/p>\n

These are decorated (i.e. “mangled”) names.  <\/span>For most of these, you can probably guess what the name is actually referring to.  <\/span><\/font><\/font><\/p>\n

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

<\/font><\/font><\/i><\/p>\n

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

public<\/span>: __thiscall<\/span> CSimpleClass::CSimpleClass(int<\/span>)<\/p>\n

<\/span><\/p>\n

public<\/span>: __thiscall<\/span> CSimpleClass::~CSimpleClass(void<\/span>)<\/p>\n

<\/span><\/p>\n

public<\/span>: class<\/span> CSimpleClass & __thiscall<\/span> CSimpleClass::operator<\/span>=(class<\/span> CSimpleClass const<\/span> &)<\/p>\n

<\/span><\/p>\n

const<\/span> CSimpleClass::`vftable’<\/p>\n

<\/span><\/p>\n

public<\/span>: void<\/span> __thiscall<\/span> CSimpleClass::M1(void<\/span>)<\/p>\n

<\/span><\/p>\n

public<\/span>: virtual<\/span> void<\/span> __thiscall<\/span> CSimpleClass::V0(void<\/span>)<\/p>\n

<\/span><\/p>\n

public<\/span>: virtual<\/span> void<\/span> __thiscall<\/span> CSimpleClass::V1(int<\/span>)<\/p>\n

<\/span><\/p>\n

public<\/span>: virtual<\/span> void<\/span> __thiscall<\/span> CSimpleClass::V2(void<\/span>)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Other than the methods we explicitly defined, there is also a compiler generated assignment operator and a reference to the vtable for this class.  <\/span>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.  <\/span><\/font><\/font><\/p>\n

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

(Note: I am only dealing with single inheritance here.  <\/span>With multiple inheritance, there are multiple vtables and vtable pointers.)<\/p>\n

<\/font><\/font><\/i><\/p>\n

[StructLayout(LayoutKind.Sequential, Pack = 4)]<\/p>\n

<\/span><\/p>\n

public<\/span> unsafe struct<\/span> __CSimpleClass<\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

public<\/span> IntPtr* _vtable;<\/p>\n

<\/span><\/p>\n

public<\/span> int<\/span> value;<\/p>\n

<\/span><\/p>\n

}<\/p>\n

<\/span><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

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

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

<\/font><\/font><\/i><\/p>\n

There are calls in the code below to Memory.Alloc and Memory.Free.  <\/span>These were implemented by me and just forward to HeapAlloc\/Free in kernel32.dll.<\/font><\/p>\n

public<\/span> unsafe class<\/span> CSimpleClass : IDisposable<\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

    <\/span>private<\/span> __CSimpleClass* _cpp;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>\/\/ CSimpleClass constructor and destructor<\/p>\n

<\/span><\/span><\/p>\n

    <\/span>[DllImport(“cppexp.dll”<\/span>, EntryPoint = “??0CSimpleClass@@QAE@H@Z”<\/span>, CallingConvention = CallingConvention.ThisCall)]<\/p>\n

<\/span><\/p>\n

    <\/span>private<\/span> static<\/span> extern<\/span> int<\/span> _CSimpleClass_Constructor(__CSimpleClass* ths, int<\/span> value);<\/p>\n

<\/span><\/p>\n

    <\/span>[DllImport(“cppexp.dll”<\/span>, EntryPoint = “??1CSimpleClass@@QAE@XZ”<\/span>, CallingConvention = Cal\nlingConvention.ThisCall)]<\/p>\n

<\/span><\/p>\n

    <\/span>private<\/span> static<\/span> extern<\/span> int<\/span> _CSimpleClass_Destructor(__CSimpleClass* ths);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>\/\/      <\/span>void M1();<\/p>\n

<\/span><\/span><\/p>\n

    <\/span>[DllImport(“cppexp.dll”<\/span>, EntryPoint = “?M1@CSimpleClass@@QAEXXZ”<\/span>, CallingConvention = CallingConvention.ThisCall)]<\/p>\n

<\/span><\/p>\n

    <\/span>private<\/span> static<\/span> extern<\/span> void<\/span> _M1(__CSimpleClass* ths);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>public<\/span> CSimpleClass(int<\/span> value)<\/p>\n

<\/span><\/p>\n

    <\/span>{<\/p>\n

<\/span><\/p>\n

        <\/span>\/\/Allocate storage for object<\/p>\n

<\/span><\/span><\/p>\n

        <\/span>_cpp = (__CSimpleClass*)Memory.Alloc(sizeof<\/span>(__CSimpleClass));<\/p>\n

<\/span><\/p>\n

        <\/span>\/\/Call constructor<\/p>\n

<\/span><\/span><\/p>\n

        <\/span>_CSimpleClass_Constructor(_cpp, value);<\/p>\n

<\/span><\/p>\n

    <\/span>}<\/p>\n

<\/span><\/p>\n

    <\/span>public<\/span> void<\/span> Dispose()<\/p>\n

<\/span><\/p>\n

    <\/span>{<\/p>\n

<\/span><\/p>\n

        <\/span>\/\/call destructor<\/p>\n

<\/span><\/span><\/p>\n

        <\/span>_CSimpleClass_Destructor(_cpp);<\/p>\n

<\/span><\/p>\n

        <\/span>\/\/release memory<\/p>\n

<\/span><\/span><\/p>\n

        <\/span>Memory.Free(_cpp);<\/p>\n

<\/span><\/p>\n

        <\/span>_cpp = null;<\/p>\n

<\/span><\/p>\n

    <\/span>}<\/p>\n

<\/span><\/p>\n

    <\/span>public<\/span> void<\/span> M1()<\/p>\n

<\/span><\/p>\n

    <\/span>{<\/p>\n

<\/span><\/p>\n

     <\/span><\/span><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

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 […]<\/p>\n","protected":false},"author":289,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-4713","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"

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 […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/4713","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/289"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=4713"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/4713\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=4713"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=4713"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=4713"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}