Classes written in C # using C + +-encapsulated with managed C + + [go]

Now the application development under Windows, VS. NET occupies the majority of the share. So many people who used to develop VC + + have turned to use more powerful vs.net. In this case, there are many developers who are faced with the problem of how to use C + + to develop good classes in C #. Here is a complete example of how to encapsulate a C + + class in Managed C + + for use in C #.

For example, there is now a DLL written by C + + with the project named Nativecppdll, which outputs a CPerson class. Here is the specific code:

2. NativeCppDll.h
4. #pragma once
6. #ifndef Lx_dll_class_exports
8. #define Lx_dll_class __declspec (dllexport)
10. #else
12. #define Lx_dll_class __declspec (dllimport)
14. #endif
16. class Lx_dll_class CPerson
18. {
20. Public:
22. CPerson ();
24. CPerson (const wchar_t *pname, const wchar_t csex, int iage);
26. void SetName (const wchar_t *pname);
28. wchar_t * GetName ();
30. void Setsex (const wchar_t csex);
32. wchar_t Getsex ();
34. void Setage (int iage);
36. int Getage ();
38. wchar_t * GetLastError ();
40. Private:
42. wchar_t m_szname[128];
44. wchar_t M_csex;
46. int m_iage;
48. wchar_t m_szlasterror[128];
50. void ShowError ();
52. };
54. NativeCppDll.cpp
56. #include "stdafx.h"
58. #include "NativeCppDll.h"
60. #include
62. #include
64. using namespace std;
66. Cperson::cperson ()
68. {
70. wcscpy_s (M_szname, _t ("No Name"));
72. M_csex = ' N ';
74. m_iage = 0;
76. wcscpy_s (M_szlasterror, _t ("No Error"));
78. }
80. Cperson::cperson (const wchar_t *pname, const wchar_t csex, int iage)
82. {
84. wcscpy_s (M_szlasterror, _t ("No Error"));
86. SetName (PName);
88. Setsex (Csex);
90. Setage (iage);
92. }
94. void Cperson::setname (const wchar_t *pname)
96. {
98. if ((PName = = NULL) | | (Wcslen (pName) = = 0) | | (Wcslen (PName) > 127))
100. {
102. wcscpy_s (M_szname, _t ("No Name"));
104. wcscpy_s (M_szlasterror, _t ("The length of the input name is out of range."));
106. ShowError ();
108. return;
110. }
112. wcscpy_s (M_szname, pName);
114. }
116. wchar_t * Cperson::getname ()
118. {
120. return M_szname;
122. }
124. void Cperson::setsex (const wchar_t csex)
126. {
128. if (Csex! = ' F ') && (csex! = ' m ') && (csex! = ' m ') && (csex! = ' f ') ))
130. {
132. M_csex = ' N ';
134. wcscpy_s (M_szlasterror, _t ("The input sex is out of [f/m]."));
136. ShowError ();
140. return;
142. }
144. M_csex = Csex;
146. }
148. wchar_t Cperson::getsex ()
150. {
152. return M_csex;
154. }
156. void Cperson::setage (int iage)
158. {
160. if ((iage < 0) | | (Iage > 150))
162. {
164. m_iage = 0;
166. wcscpy_s (M_szlasterror, _t ("The input age was out ofrange."));
168. ShowError ();
170. return;
172. }
174. M_iage = iage;
176. }
178. int Cperson::getage ()
180. {
182. return m_iage;
184. }
186. wchar_t * Cperson::getlasterror ()
188. {
190. return M_szlasterror;
192. }
194. void Cperson::showerror ()
196. {
198. Cerr << m_szlasterror << Endl;
200. }

This is a typical DLL developed by C + +, outputting a complete C + + class. What if you need to develop a C # project now and use the C + + class CPerson output from this DLL? For this example, class CPerson is very small and can be used to re-write a class like this C + + class in C #. However, if the required C + + classes are large, or many times, rewriting works will be very large. And it's not reusing existing code, wasting existing resources, and creating time-consuming and laborious development.
Of course, there are ways to solve this problem. That is to encapsulate the C + + class with managed C + + and then provide it to C # for use. The following code is used to describe in detail how to encapsulate the C + + class with managed C + +.
First, create a managed C + + DLL project Managecppdll, and add the following code inside:

2. ManageCppDll.h
4. #pragma once
6. #define Lx_dll_class_exports
8. #include ". /nativecppdll/nativecppdll.h "
10. using namespace System;
12. namespace Managecppdll
14. {
16. Public ref class person
18. {
20. //Wrapper public member functions for all class CPerson
22. Public:
24. Person ();
26. Person (String ^ strName, Char csex, int iage);
28. ~person ();
30. Property String ^ Name
32. {
34. void Set (String ^ strName);
36. String ^ get ();
38. }
40. Property Char Sex
42. {
44. void Set (Char csex);
46. Char get ();
48. }
50. Property int Age
52. {
54. void Set (int iage);
56. int get ();
58. }
60. String ^ GetLastError ();
62. Private:
64. //Class CPerson pointer, used to invoke the member function of class CPerson
66. CPerson *m_pimp;
68. };
70. };

As you can see from this header file, this is the wrapper for C + + class CPerson. All public member functions of the class person are the same as the C + + class CPerson, except that the parameters and return values of the member functions are changed to the managed C + + type, which is the first condition for the class person to be used in C #. Of course, only the public member functions need to be encapsulated, and no encapsulation is necessary for the protection of member functions and private member functions.
The class person has only one private member variable: A pointer to a class CPerson. The implementation of all member functions of the class person is accomplished by invoking the corresponding member function of the class CPerson by this cperson pointer.
Here is the specific implementation code:

2. ManageCppDll.cpp
4. #include "stdafx.h"
6. #include "ManageCppDll.h"
8. #include
10. namespace Managecppdll
12. {
14. //Create an object of class CPerson in the constructor and destroy the object in the destructor
16. //All member function implementations are implemented by pointer M_pimp calling the corresponding member function of class CPerson
18. Person::P Erson ()
20. {
22. M_pimp = new CPerson ();
24. }
26. Person::P Erson (String ^ strName, Char csex, int iage)
28. {
30. //Convert string to a pointer that C + + can recognize
32. pin_ptr<</span>const wchar_t> wcname = PtrToStringChars (strName);
34. M_pimp = new CPerson (Wcname, Csex, iage);
36. }
38. Person::~person ()
40. {
42. //Delete the CPerson object in the destructor
44. Delete m_pimp;
46. }
48. void Person::name::set (String ^ strName)
50. {
52. pin_ptr<</span>const wchar_t> wcname = PtrToStringChars (strName);
54. M_pimp->setname (Wcname);
56. }
58. String ^ Person::name::get ()
60. {
62. return gcnew String (M_pimp->getname ());
64. }
66. void Person::sex::set (Char csex)
68. {
70. M_pimp->setsex (Csex);
72. }
74. Char Person::sex::get ()
76. {
78. return m_pimp->getsex ();
80. }
82. void Person::age::set (int iage)
84. {
86. M_pimp->setage (iage);
88. }
90. int Person::age::get ()
92. {
94. return m_pimp->getage ();
96. }
98. String ^ Person::getlasterror ()
100. {
102. return gcnew String (M_pimp->getlasterror ());
104. }
106. };

If you want to use class person in C #, first add a reference to ManageCppDll.dll, and then you can use the class person as you would with a normal C # class. such as the following code:

1. using Managecppdll;
2. Person person = New person ();
3. Person. Name = "Starlee";
4. Person. Sex = ' M ';
5. Person. Age = 28;

Familiar with the design pattern to see the above code will certainly find that this design is the same as bridge mode. In fact, the above method is also a bridge pattern, managed C + + serves as a bridge for C # to use classes developed in C + +. In addition, this form can also be understood as adapter mode, managed C + + class person is the C + + class CPerson an adapter. With this bridge, it is easy to reuse classes that were previously developed in C + +, so that these C + + classes continue to play their role in C #, making development more effective.

Blog Source: http://blog.csdn.net/starlee/article/details/2864588

Classes written in C # using C + +-encapsulated with managed C + + [go]