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

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

1. //NativeCppDll.h
3. #pragmaonce
5. #ifndefLX_DLL_CLASS_EXPORTS
6. #defineLX_DLL_CLASS__declspec(dllexport)
7. #else
8. #defineLX_DLL_CLASS__declspec(dllimport)
9. #endif
11. classLX_DLL_CLASSCPerson
12. {
13. public:
14. CPerson();
15. CPerson(constwchar_t*pName,constwchar_tcSex,intiAge);
17. voidSetName(constwchar_t*pName);
18. wchar_t*GetName();
20. voidSetSex(constwchar_tcSex);
21. wchar_tGetSex();
23. voidSetAge(intiAge);
24. intGetAge();
26. wchar_t*GetLastError();
28. private:
29. wchar_tm_szName[128];
30. wchar_tm_cSex;
31. intm_iAge;
32. wchar_tm_szLastError[128];
34. voidShowError();
35. };
37. //NativeCppDll.cpp
39. #include"stdafx.h"
41. #include"NativeCppDll.h"
42. #include<iostream>
43. #include<tchar.h>
45. usingnamespacestd;
47. CPerson::CPerson()
48. {
49. wcscpy_s(m_szName,_T("NoName"));
50. m_cSex='N';
51. m_iAge=0;
53. wcscpy_s(m_szLastError,_T("NoError"));
54. }
56. CPerson::CPerson(constwchar_t*pName,constwchar_tcSex,intiAge)
57. {
58. wcscpy_s(m_szLastError,_T("NoError"));
60. SetName(pName);
61. SetSex(cSex);
62. SetAge(iAge);
63. }
65. voidCPerson::SetName(constwchar_t*pName)
66. {
67. if((pName==NULL)||(wcslen(pName)==0)||(wcslen(pName)>127))
68. {
69. wcscpy_s(m_szName,_T("NoName"));
71. wcscpy_s(m_szLastError,_T("Thelengthoftheinputnameisoutofrange."));
73. ShowError();
75. return;
76. }
78. wcscpy_s(m_szName,pName);
79. }
81. wchar_t*CPerson::GetName()
82. {
83. returnm_szName;
84. }
86. voidCPerson::SetSex(constwchar_tcSex)
87. {
88. if((cSex!='F')&&(cSex!='M')&&(cSex!='m')&&(cSex!='f'))
89. {
90. m_cSex='N';
92. wcscpy_s(m_szLastError,_T("Theinputsexisoutof[F/M]."));
94. ShowError();
96. return;
97. }
99. m_cSex=cSex;
100. }
102. wchar_tCPerson::GetSex()
103. {
104. returnm_cSex;
105. }
107. voidCPerson::SetAge(intiAge)
108. {
109. if((iAge<0)||(iAge>150))
110. {
111. m_iAge=0;
113. wcscpy_s(m_szLastError,_T("Theinputageisoutofrange."));
115. ShowError();
117. return;
118. }
120. m_iAge=iAge;
121. }
123. intCPerson::GetAge()
124. {
125. returnm_iAge;
126. }
128. wchar_t*CPerson::GetLastError()
129. {
130. returnm_szLastError;
131. }
133. voidCPerson::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. #pragmaonce
4. #defineLX_DLL_CLASS_EXPORTS
6. #include"../NativeCppDll/NativeCppDll.h"
8. usingnamespaceSystem;
10. namespaceManageCppDll
11. {
12. publicrefclassPerson
13. {
14. //包装所有类CPerson的公有成员函数
15. public:
16. Person();
17. Person(String^strName,CharcSex,intiAge);
19. ~Person();
21. propertyString^Name
22. {
23. voidset(String^strName);
24. String^get();
25. }
27. propertyCharSex
28. {
29. voidset(CharcSex);
30. Charget();
31. }
33. propertyintAge
34. {
35. voidset(intiAge);
36. intget();
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. namespaceManageCppDll
9. {
10. //在构造函数中创建类CPerson的对象并在析构函数中将该对象销毁
11. //所有的成员函数实现都是通过指针m_pImp调用类CPerson的相应成员函数实现
13. Person::Person()
14. {
15. m_pImp=newCPerson();
16. }
18. Person::Person(String^strName,CharcSex,intiAge)
19. {
20. //将string转换成C++能识别的指针
21. pin_ptr<constwchar_t>wcName=PtrToStringChars(strName);
23. m_pImp=newCPerson(wcName,cSex,iAge);
24. }
26. Person::~Person()
27. {
28. //在析构函数中删除CPerson对象
29. deletem_pImp;
30. }
32. voidPerson::Name::set(String^strName)
33. {
34. pin_ptr<constwchar_t>wcName=PtrToStringChars(strName);
36. m_pImp->SetName(wcName);
37. }
39. String^Person::Name::get()
40. {
41. returngcnewString(m_pImp->GetName());
42. }
44. voidPerson::Sex::set(CharcSex)
45. {
46. m_pImp->SetSex(cSex);
47. }
49. CharPerson::Sex::get()
50. {
51. returnm_pImp->GetSex();
52. }
54. voidPerson::Age::set(intiAge)
55. {
56. m_pImp->SetAge(iAge);
57. }
59. intPerson::Age::get()
60. {
61. returnm_pImp->GetAge();
62. }
64. String^Person::GetLastError()
65. {
66. returngcnewString(m_pImp->GetLastError());
67. }
68. };

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

1. usingManageCppDll;
3. Personperson=newPerson();
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#中发挥它们的效用，让开发变得事半功倍。