首页 / C# / 在C#中使用C++编写的类——用托管C++进行封装[转]

在C#中使用C++编写的类——用托管C++进行封装[转]

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了在C#中使用C++编写的类——用托管C++进行封装[转]，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4773字，纯文字阅读大概需要7分钟。

内容图文

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

   比如，现在有一个工程名为NativeCppDll的由C++编写的DLL，里面输出了一个CPerson类。下面是具体的代码：
  1. // NativeCppDll.h
  2. #pragma once
  3. #ifndef LX_DLL_CLASS_EXPORTS
  4.     #define LX_DLL_CLASS __declspec(dllexport)
  5. #else
  6.     #define LX_DLL_CLASS __declspec(dllimport)
  7. #endif
  8. class LX_DLL_CLASS CPerson
  9. {
  10. public:
  11.     CPerson();
  12.     CPerson(const wchar_t *pName, const wchar_t cSex, int iAge);
  13.     void SetName(const wchar_t *pName);
  14.     wchar_t * GetName();
  15.     void SetSex(const wchar_t cSex);
  16.     wchar_t GetSex();
  17.     void SetAge(int iAge);
  18.     int GetAge();
  19.     wchar_t * GetLastError();
  20. private:
  21.     wchar_t m_szName[128];
  22.     wchar_t m_cSex;
  23.     int m_iAge;
  24.     wchar_t m_szLastError[128];
  25.     void ShowError();
  26. };
  27. // NativeCppDll.cpp
  28. #include "stdafx.h"
  29. #include "NativeCppDll.h"
  30. #include 
  31. #include 
  32. using namespace std;
  33. CPerson::CPerson()
  34. {
  35.     wcscpy_s(m_szName, _T("No Name"));
  36.     m_cSex = ‘N‘;
  37.     m_iAge = 0;
  38.     wcscpy_s(m_szLastError, _T("No Error"));
  39. }
  40. CPerson::CPerson(const wchar_t *pName, const wchar_t cSex, int iAge)
  41. {
  42.     wcscpy_s(m_szLastError, _T("No Error"));
  43.     SetName(pName);
  44.     SetSex(cSex);
  45.     SetAge(iAge);
  46. }
  47. void CPerson::SetName(const wchar_t *pName)
  48. {
  49.     if ((pName == NULL) || (wcslen(pName) == 0) || (wcslen(pName) > 127))
  50.     {
  51.         wcscpy_s(m_szName, _T("No Name"));
  52.         wcscpy_s(m_szLastError, _T("The length of the input name is out of range."));
  53.         ShowError();
  54.         return;
  55.     }
  56.     wcscpy_s(m_szName, pName);
  57. }
  58. wchar_t * CPerson::GetName()
  59. {
  60.     return m_szName;
  61. }
  62. void CPerson::SetSex(const wchar_t cSex)
  63. {
  64.     if ((cSex != ‘F‘) && (cSex != ‘M‘) && (cSex != ‘m‘) && (cSex != ‘f‘))
  65.     {
  66.         m_cSex = ‘N‘;
  67.         wcscpy_s(m_szLastError, _T("The input sex is out of [F/M]."));
  68.         ShowError();
  69.         
  70.         return;
  71.     }
  72.     m_cSex = cSex;
  73. }
  74. wchar_t CPerson::GetSex()
  75. {
  76.     return m_cSex;
  77. }
  78. void CPerson::SetAge(int iAge)
  79. {
  80.     if ((iAge < 0) || (iAge > 150))
  81.     {
  82.         m_iAge = 0;
  83.         wcscpy_s(m_szLastError, _T("The input age is out of range."));
  84.         ShowError();
  85.         return;
  86.     }
  87.     m_iAge = iAge;
  88. }
  89. int CPerson::GetAge()
  90. {
  91.     return m_iAge;
  92. }
  93. wchar_t * CPerson::GetLastError()
  94. {
  95.     return m_szLastError;
  96. }
  97. void CPerson::ShowError()
  98. {
  99.     cerr << m_szLastError << endl;
  100. }

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

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

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

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

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

  1. using ManageCppDll;
  2. Person person = new Person();
  3. person.Name = "StarLee";
  4. person.Sex = ‘M‘;
  5. person.Age = 28;

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

 

博客来源：http://blog.csdn.net/starlee/article/details/2864588

原文：http://www.cnblogs.com/mazhenyu/p/4460878.html

内容总结

以上是互联网集市为您收集整理的在C#中使用C++编写的类——用托管C++进行封装[转]全部内容，希望文章能够帮你解决在C#中使用C++编写的类——用托管C++进行封装[转]所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1076732.html

来源：【匿名】