c++/c#类互用

在C#中使用C++编写的类

转自 http://blog.csdn.net/starlee/article/details/2864588

     现在在Windows下的应用程序开发，VS.Net占据了绝大多数的份额。因此很多以前搞VC++开发的人都转向用更强大的VS.Net。在这种情况下，有很多开发人员就面临了如何在C#中使用C++开发好的类的问题。下面就用一个完整的实例来详细说明怎样用托管C++封装一个C++类以提供给C#使用。
    比如，现在有一个工程名为NativeCppDll的由C++编写的DLL，里面输出了一个CPerson类。下面是具体的代码：

1. // NativeCppDll.h
3. #pragma once
5. #ifndef LX_DLL_CLASS_EXPORTS
6.     #define LX_DLL_CLASS __declspec(dllexport)
7. #else
8.     #define LX_DLL_CLASS __declspec(dllimport)
9. #endif
11. class LX_DLL_CLASS CPerson
12. {
13. public:
14.     CPerson();
15.     CPerson(const wchar_t *pName, const wchar_t cSex, int iAge);
17.     void SetName(const wchar_t *pName);
18.     wchar_t * GetName();
20.     void SetSex(const wchar_t cSex);
21.     wchar_t GetSex();
23.     void SetAge(int iAge);
24.     int GetAge();
26.     wchar_t * GetLastError();
28. private:
29.     wchar_t m_szName[128];
30.     wchar_t m_cSex;
31.     int m_iAge;
32.     wchar_t m_szLastError[128];
34.     void ShowError();
35. };
37. // NativeCppDll.cpp
39. #include "stdafx.h"
41. #include "NativeCppDll.h"
42. #include <iostream>
43. #include <tchar.h>
45. using namespace std;
47. CPerson::CPerson()
48. {
49.     wcscpy_s(m_szName, _T("No Name"));
50.     m_cSex = 'N';
51.     m_iAge = 0;
53.     wcscpy_s(m_szLastError, _T("No Error"));
54. }
56. CPerson::CPerson(const wchar_t *pName, const wchar_t cSex, int iAge)
57. {
58.     wcscpy_s(m_szLastError, _T("No Error"));
60.     SetName(pName);
61.     SetSex(cSex);
62.     SetAge(iAge);
63. }
65. void CPerson::SetName(const wchar_t *pName)
66. {
67.     if ((pName == NULL) || (wcslen(pName) == 0) || (wcslen(pName) > 127))
68.     {
69.         wcscpy_s(m_szName, _T("No Name"));
71.         wcscpy_s(m_szLastError, _T("The length of the input name is out of range."));
73.         ShowError();
75.         return;
76.     }
78.     wcscpy_s(m_szName, pName);
79. }
81. wchar_t * CPerson::GetName()
82. {
83.     return m_szName;
84. }
86. void CPerson::SetSex(const wchar_t cSex)
87. {
88.     if ((cSex != 'F') && (cSex != 'M') && (cSex != 'm') && (cSex != 'f'))
89.     {
90.         m_cSex = 'N';
92.         wcscpy_s(m_szLastError, _T("The input sex is out of [F/M]."));
94.         ShowError();
95.         
96.         return;
97.     }
99.     m_cSex = cSex;
100. }
102. wchar_t CPerson::GetSex()
103. {
104.     return m_cSex;
105. }
107. void CPerson::SetAge(int iAge)
108. {
109.     if ((iAge < 0) || (iAge > 150))
110.     {
111.         m_iAge = 0;
113.         wcscpy_s(m_szLastError, _T("The input age is out of range."));
115.         ShowError();
117.         return;
118.     }
120.     m_iAge = iAge;
121. }
123. int CPerson::GetAge()
124. {
125.     return m_iAge;
126. }
128. wchar_t * CPerson::GetLastError()
129. {
130.     return m_szLastError;
131. }
133. void CPerson::ShowError()
134. {
135.     cerr << m_szLastError << endl;
136. }

    这是一个很典型的由C++开发的DLL，输出一个完整的C++类。如果现在要求开发一个C#工程，需要用到这个DLL中输出的C++类CPerson，该怎么办呢？针对这个例子来说，类CPerson非常小，可以用C#重新写一个跟这个C++类一样的类。可是，如果需要的C++类很大，或者很多的时候，重写工程将非常庞大。而且这样没有对现有的代码进行重用，浪费了现有资源，开发起来费时费力。
    当然，还是有方法解决这个问题的。那就是用托管C++将C++类给封装一下，然后再提供给C#来使用。下面就用代码来详细说明怎样用托管C++来封装上面的那个C++类。
    首先，要创建一个托管C++的DLL工程ManageCppDll，然后在里面添加下面的代码：   

1. // ManageCppDll.h
3. #pragma once
4. #define LX_DLL_CLASS_EXPORTS
6. #include "../NativeCppDll/NativeCppDll.h"
8. using namespace System;
10. namespace ManageCppDll 
11. {
12.     public ref class Person
13.     {
14.     // 包装所有类CPerson的公有成员函数
15.     public:
16.         Person();
17.         Person(String ^ strName, Char cSex, int iAge);
19.         ~Person();
21.         property String ^ Name
22.         {
23.             void set(String ^ strName);
24.             String ^ get();
25.         }
27.         property Char Sex
28.         {
29.             void set(Char cSex);
30.             Char get();
31.         }
33.         property int Age
34.         {
35.             void set(int iAge);
36.             int get();
37.         }
39.         String ^ GetLastError();
41.     private:
42.         // 类CPerson的指针，用来调用类CPerson的成员函数
43.         CPerson *m_pImp;
44.     };
45. };

    从这个头文件就能看出来，这是对C++类CPerson的包装。类Person的所有公有成员函数都跟C++类CPerson一样，只不过成员函数的参数和返回值就改成了托管C++的类型，这也是让类Person能在C#中使用的首要条件。当然只需要对公有成员函数进行封装，对于保护成员函数和私有成员函数则不必做任何封装。
    类Person仅有一个私有的成员变量：一个类CPerson的指针。而类Person的所有成员函数的实现都是靠这个CPerson指针来调用类CPerson的相应成员函数来实现。
    下面是具体的实现代码：

1. // ManageCppDll.cpp
3. #include "stdafx.h"
5. #include "ManageCppDll.h"
6. #include <vcclr.h>
8. namespace ManageCppDll 
9. {
10.     // 在构造函数中创建类CPerson的对象并在析构函数中将该对象销毁
11.     // 所有的成员函数实现都是通过指针m_pImp调用类CPerson的相应成员函数实现
13.     Person::Person()
14.     {
15.         m_pImp = new CPerson();
16.     }
18.     Person::Person(String ^ strName, Char cSex, int iAge)
19.     {
20.         // 将string转换成C++能识别的指针
21.         pin_ptr<const wchar_t> wcName = PtrToStringChars(strName);
23.         m_pImp = new CPerson(wcName, cSex, iAge);
24.     }
26.     Person::~Person()
27.     {
28.         // 在析构函数中删除CPerson对象
29.         delete m_pImp;
30.     }
32.     void Person::Name::set(String ^ strName)
33.     {
34.         pin_ptr<const wchar_t> wcName = PtrToStringChars(strName);
36.         m_pImp->SetName(wcName);
37.     }
39.     String ^ Person::Name::get()
40.     {
41.         return gcnew String(m_pImp->GetName());
42.     }
44.     void Person::Sex::set(Char cSex)
45.     {
46.         m_pImp->SetSex(cSex);
47.     }
49.     Char Person::Sex::get()
50.     {
51.         return m_pImp->GetSex();
52.     }
54.     void Person::Age::set(int iAge)
55.     {
56.         m_pImp->SetAge(iAge);
57.     }
59.     int  Person::Age::get()
60.     {
61.         return m_pImp->GetAge();
62.     }
64.     String ^ Person::GetLastError()
65.     {
66.         return gcnew String(m_pImp->GetLastError());
67.     }
68. };

    如果要在C#中使用类Person，首先要添加对ManageCppDll.dll的引用，然后就可以像用普通的C#类一样的使用类Person了。比如下面这样的代码：

1. using ManageCppDll;
3. Person person = new Person();
5. person.Name = "StarLee";
6. person.Sex = 'M';
7. person.Age = 28;

    熟悉设计模式的看了上面的代码肯定会发现,这样的设计跟BRIDGE模式如出一辙。其实，上面的方法也算是一种BRIDGE模式，由托管C++充当了C#中使用用C++开发的类的桥梁。另外，这种形式也可以理解为ADAPTER模式，托管C++类Person就是C++类CPerson的一个适配器。通过这个桥梁，可以很容易的重用以前用C++开发的类，让这些C++类继续在C#中发挥它们的效用，让开发变得事半功倍。

================================================================================

在C++中使用C#编写的类

转自 http://blog.csdn.net/starlee/article/details/2897970

     在那篇《在C#中使用C++编写的类》中我介绍了如何在C#中使用C++编写的类。可是由于C#在用户界面设计、数据库存储和XML文件读取等方面的优势，有时候也会出现要在C++中使用C#编写的类的情况。下面就用一个完整的实例来说明怎样在C++中使用C#编写的类。
    比如说，现在有一个用C#编写的DLL工程CsharpDll里面有一个Person类：

1. // Person.cs
3. using System;
5. namespace CsharpDll
6. {
7.     public class Person
8.     {
9.         public Person()
10.         {
11.             Name = "No Name";
12.             Sex = 'N';
13.             Age = 0;
15.             m_strLastError = "No Error";
16.         }
18.         public Person(string strName, char cSex, int iAge)
19.         {
20.             m_strLastError = "No Error";
22.             Name = strName;
23.             Sex = cSex;
24.             Age = iAge;
25.         }
27.         public string Name
28.         {
29.             get
30.             {
31.                 return m_strName;
32.             }
34.             set
35.             {
36.                 if ((String.IsNullOrEmpty(value)) || (value.Length > 127))
37.                 {
38.                     m_strName = "No Name";
40.                     m_strLastError = "The length of the input name is out of range.";
42.                     return;
43.                 }
45.                 m_strName = value;
46.             }
47.         }
49.         public char Sex
50.         {
51.             get
52.             {
53.                 return m_cSex;
54.             }
56.             set
57.             {
58.                 if ((value != 'F') && (value != 'M') && (value != 'm') && (value != 'f'))
59.                 {
60.                     m_cSex = 'N';
62.                     m_strLastError = "The input sex is out of [F/M].";
64.                     return;
65.                 }
67.                 m_cSex = value;
68.             }
69.         }
71.         public int Age
72.         {
73.             get
74.             {
75.                 return m_iAge;
76.             }
78.             set
79.             {
80.                 if ((value < 0) || (value > 150))
81.                 {
82.                     m_iAge = 0;
84.                     m_strLastError = "The input age is out of range.";
86.                     return;
87.                 }
89.                 m_iAge = value;
90.             }
91.         }
93.         public string LastError
94.         {
95.             get
96.             {
97.                 return m_strLastError;
98.             }
99.         }
101.         private string m_strName;
102.         private char m_cSex;
103.         private int m_iAge;
104.         private string m_strLastError;
105.     }
106. }

    如果需要在C++中使用这个C#编写的Person类，就需要用托管C++来对这个C#进行包装，将它包装成一个C++能用的类。
    首先，要创建一个托管C++的DLL工程ManageCppDll。并且，要添加对CsharpDll.dll的引用。然后对C#类所有的公有属性和方法进行包装。下面是具体的代码：

1. // ManageCppDll.h
3. #pragma once
5. #ifndef LX_DLL_CLASS_EXPORTS
6.     #define LX_DLL_CLASS __declspec(dllexport)
7. #else
8.     #define LX_DLL_CLASS __declspec(dllimport)
9. #endif
11. class LX_DLL_CLASS CPerson
12. {
13. public:
14.     CPerson();
15.     CPerson(const wchar_t *pName, const wchar_t cSex, int iAge);
17.     ~CPerson();
19.     void SetName(const wchar_t *pName);
20.     wchar_t * GetName();
22.     void SetSex(const wchar_t cSex);
23.     wchar_t GetSex();
25.     void SetAge(int iAge);
26.     int GetAge();
28.     wchar_t * GetLastError();
30. private:
31.     // 用一个void指针指向Person的对象
32.     // 所有公有成员函数的实现都是通过这个对象来实现
33.     void *m_pImp;
35.     wchar_t m_szName[128];
36.     wchar_t m_szLastError[128];
37. };
39. // ManageCppDll.cpp
41. #include "stdafx.h"
43. #include "ManageCppDll.h"
45. #include <vcclr.h>
46. #include <string.h>
47. #include <stdlib.h>
49. using namespace System;
50. using namespace System::Runtime::InteropServices;
52. using namespace CsharpDll;
54. // 将GCHandle转换成为void指针
55. #define __GCHANDLE_TO_VOIDPTR(x) ((GCHandle::operator System::IntPtr(x)).ToPointer())
56. // 将void指针转换为GCHandle
57. #define __VOIDPTR_TO_GCHANDLE(x) (GCHandle::operator GCHandle(System::IntPtr(x)))
59. // 辅助函数
60. // 将void指针指向的对象转换成为Person对象
61. inline Person ^ GetImpObj(void *pHandle)
62. {
63.     Person ^ person = nullptr;
65.     if (pHandle != NULL)
66.     {
67.         person = static_cast<Person^>(__VOIDPTR_TO_GCHANDLE(pHandle).Target);
68.     }
70.     return person;
71. }
73. CPerson::CPerson()
74. {
75.     m_pImp = NULL;
77.     Person ^ person = gcnew Person();
79.     // 创建GCHandle并将它转换成void指针保存到成员变量中
80.     GCHandle handle = GCHandle::Alloc(person);
81.     m_pImp = __GCHANDLE_TO_VOIDPTR(handle); 
82. }
84. CPerson::CPerson(const wchar_t *pName, const wchar_t cSex, int iAge)
85. {
86.     m_pImp = NULL;
88.     Person ^ person = gcnew Person();
89.     person->Name = gcnew String(pName);
90.     person->Sex = cSex;
91.     person->Age = iAge;
93.     GCHandle handle = GCHandle::Alloc(person);
94.     m_pImp = __GCHANDLE_TO_VOIDPTR(handle);
95. }
97. CPerson::~CPerson()
98. {
99.     if (m_pImp == NULL)
100.         return;
102.     // 释放GCHandle
103.     GCHandle handle = __VOIDPTR_TO_GCHANDLE(m_pImp);
104.     handle.Free();
106.     m_pImp = NULL;
107. }
109. void CPerson::SetName(const wchar_t *pName)
110. {
111.     // 将void指针转换成Person指针
112.     // 并用该指针调用相应的公有属性或方法
113.     Person ^ person = GetImpObj(m_pImp);
114.     person->Name = gcnew String(pName);
115. }
117. wchar_t * CPerson::GetName()
118. {
119.     Person ^ person = GetImpObj(m_pImp);
121.     // 将C#返回的字符串转换为wchat_t*指针能指向的地址
122.     wchar_t * pName = static_cast<wchar_t*>(Marshal::StringToHGlobalUni(person->Name).ToPointer());
123.     wcscpy_s(m_szName, pName);
124.     Marshal::FreeHGlobal(System::IntPtr(pName)); // 释放内存
126.     return m_szName;
127. }
129. void CPerson::SetSex(const wchar_t cSex)
130. {
131.     Person ^ person = GetImpObj(m_pImp);
132.     person->Sex = cSex;
133. }
135. wchar_t CPerson::GetSex()
136. {
137.     Person ^ person = GetImpObj(m_pImp);
139.     return person->Sex;
140. }
142. void CPerson::SetAge(int iAge)
143. {
144.     Person ^ person = GetImpObj(m_pImp);
145.     person->Age = iAge;
146. }
148. int CPerson::GetAge()
149. {
150.     Person ^ person = GetImpObj(m_pImp);
152.     return person->Age;
153. }
155. wchar_t * CPerson::GetLastError()
156. {
157.     Person ^ person = GetImpObj(m_pImp);
159.     wchar_t * pLastError = static_cast<wchar_t*>(Marshal::StringToHGlobalUni(person->LastError).ToPointer());
160.     wcscpy_s(m_szLastError, pLastError);
161.     Marshal::FreeHGlobal(System::IntPtr(pLastError));
163.     return m_szLastError;
164. }

    现在对上面代码中所用到的一些相关背景知识进行一下介绍。
    GCHandle结构提供从非托管内存访问托管对象的方法。
    GCHandle.Alloc方法(Object)为指定的对象分配Normal句柄。它保护对象不被垃圾回收。当不再需要GCHandle时，必须通过Free将其释放。Normal句柄类型表示不透明句柄，这意味着无法通过此句柄解析固定对象的地址。可以使用此类型跟踪对象，并防止它被垃圾回收器回收。当非托管客户端持有对托管对象的唯一引用（从垃圾回收器检测不到该引用）时，此枚举成员很有用。
    上面的代码中，在类CPerson的构造函数中用GCHandle为C#类Person的对象分配一个句柄，并将该句柄转换为void指针存放在成员变量中，以保证这个对象不会被垃圾回收器回收。然后在类CPerson的析构函数中释放这个句柄，将C#类Person的对象的回收权交给系统。
    Marshal类提供了一个方法集，这些方法用于分配非托管内存、复制非托管内存块、将托管类型转换为非托管类型，此外还提供了在与非托管代码交互时使用的其他杂项方法。
    Marshal..::.StringToHGlobalUni方法向非托管内存复制托管String的内容。StringToHGlobalUni对于自定义封送处理或者在混合托管和非托管代码时很有用。由于该方法分配字符串所需的非托管内存，因此应始终通过调用FreeHGlobal释放内存。
    （更多关于上面介绍的背景知识可以搜索MSDN。说实在的MSDN真是一个宝库！VS能在Windows平台开发中取得绝大多数的份额，除了因为它和Windows都是微软开发的之外，MSDN的完备性功不可没！）
    通过上面的方法，就把一个C#编写的类Person用托管C++给封装成了一个C++可以使用的CPerson类。我们可以在C++的工程中像使用一般的C++类一样使用类CPerson。比如下面的代码。

1. CPerson person(_T("StarLee"), 'M', 28);
3. person.SetName(_T("StarLee"));
4. person.SetSex('M');
5. person.SetAge(28);
7. wcout << "Name: " << person.GetName() << " Sex: " << person.GetSex() << " Age: " << person.GetAge() << endl;
8. wcout << "Error: " << person.GetLastError() << endl;

    这里的方法跟《在C#中使用C++编写的类》一样，都是借用托管C++这个桥梁来沟通C++编写的类和C#编写的类，使在C++中使用C#编写的类和在C#中使用C++编写的类成为现实。