如何为BRepPrimAPI_MakeSphere类生成C#可用的自动包装器？

我有以下C++头文件：

// BRepPrimAPI_MakeSphere.hxx file
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <BRepPrim_Sphere.hxx>
#include <BRepPrimAPI_MakeOneAxis.hxx>

class gp_Pnt;
class gp_Ax2;

class BRepPrimAPI_MakeSphere : public BRepPrimAPI_MakeOneAxis
{
public:
    DEFINE_STANDARD_ALLOC

    Standard_EXPORT BRepPrimAPI_MakeSphere(const Standard_Real R);
    Standard_EXPORT Standard_Address OneAxis();
    Standard_EXPORT BRepPrim_Sphere& Sphere();

protected:


private:
    BRepPrim_Sphere mySphere;
};

对应的C++源文件：

// BRepPrimAPI_MakeSphere.cxx file
#include <BRepBuilderAPI.hxx>
#include <BRepPrimAPI_MakeSphere.hxx>
#include <gp.hxx>
#include <gp_Ax2.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>

BRepPrimAPI_MakeSphere::BRepPrimAPI_MakeSphere(const Standard_Real R) :
       mySphere(gp::XOY(),R)
{
}

Standard_Address  BRepPrimAPI_MakeSphere::OneAxis()
{
  return &mySphere;
}

BRepPrim_Sphere&  BRepPrimAPI_MakeSphere::Sphere()
{
  return mySphere;
}

相关宏定义：

# define Standard_EXPORT __declspec( dllexport )

# define DEFINE_STANDARD_ALLOC  
void* operator new (size_t theSize)                                  
{                                                                    
    return Standard::Allocate (theSize);                               
}                                                                    
void  operator delete (void* theAddress)                             
{                                                                    
    Standard::Free (theAddress);
}
void* operator new[] (size_t theSize)                               
{                                                                   
    return Standard::Allocate (theSize);                              
}                                                                   
void  operator delete[] (void* theAddress)                          
{                                                                   
    Standard::Free (theAddress);
}
void* operator new (size_t, void* theAddress)                       
{                                                                   
    return theAddress;                                                
}                                                                   
void operator delete (void*, void*)                                 
{                                                                   
}

我希望在C#代码中使用这个类，之前尝试过三种方法都没成功：

• 使用CLR包装C++代码以在C#中调用；
• 使用SWIG工具；
• 使用P/Invoke机制。

由于这个类属于一个庞大的C++库，我需要自动生成所有类的包装器以获取完整库功能，当前核心问题是处理返回类型与参数适配。我自己尝试写的导出代码如下，但显然无法在C#中使用，因为参数类型在C#中不存在：

extern "C" __declspec(dllexport) void Call_BRepPrimAPI_MakeSphere(BRepPrimAPI_MakeSphere* p, const Standard_Real R) {
    p->BRepPrimAPI_MakeSphere::BRepPrimAPI_MakeSphere(R);
}

请问为该类生成C#包装器的最佳方式是什么？

针对大型C++库自动生成C#包装器，推荐以下两种可行方案：

方案一：基于P/Invoke的手动导出层+自动生成工具 #

批量处理大型库时，手动写导出函数效率极低，可结合模板或代码生成脚本（比如Python脚本、CMake自定义命令）自动生成C导出层，再对应生成C#的P/Invoke包装类：

1. 修正C导出层的写法 #

C#无法直接识别C类类型，需把C类的操作封装成基于void指针的C风格函数，示例如下：

extern "C" {
    __declspec(dllexport) void* BRepPrimAPI_MakeSphere_Create(double R) {
        return new BRepPrimAPI_MakeSphere(R);
    }

    __declspec(dllexport) void BRepPrimAPI_MakeSphere_Destroy(void* instance) {
        delete static_cast<BRepPrimAPI_MakeSphere*>(instance);
    }

    // 返回内部对象的方法封装为void指针，C#端用IntPtr接收
    __declspec(dllexport) void* BRepPrimAPI_MakeSphere_GetSphere(void* instance) {
        auto sphereObj = static_cast<BRepPrimAPI_MakeSphere*>(instance);
        return &sphereObj->Sphere();
    }

    __declspec(dllexport) void* BRepPrimAPI_MakeSphere_GetOneAxis(void* instance) {
        auto sphereObj = static_cast<BRepPrimAPI_MakeSphere*>(instance);
        return sphereObj->OneAxis();
    }
}

注：Standard_Real本质是double，直接用C++的double对应C#的double即可。

2. C#端的P/Invoke包装类 #

对应上述导出函数，编写C#包装类，用IntPtr承载C++对象指针：

public class BRepPrimAPI_MakeSphere : IDisposable
{
    private IntPtr _instance;

    [DllImport("YourCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr BRepPrimAPI_MakeSphere_Create(double R);

    [DllImport("YourCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern void BRepPrimAPI_MakeSphere_Destroy(IntPtr instance);

    [DllImport("YourCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr BRepPrimAPI_MakeSphere_GetSphere(IntPtr instance);

    [DllImport("YourCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr BRepPrimAPI_MakeSphere_GetOneAxis(IntPtr instance);

    public BRepPrimAPI_MakeSphere(double R)
    {
        _instance = BRepPrimAPI_MakeSphere_Create(R);
        if (_instance == IntPtr.Zero)
            throw new InvalidOperationException("实例创建失败");
    }

    public IntPtr Sphere => BRepPrimAPI_MakeSphere_GetSphere(_instance);
    public IntPtr OneAxis => BRepPrimAPI_MakeSphere_GetOneAxis(_instance);

    public void Dispose()
    {
        if (_instance != IntPtr.Zero)
        {
            BRepPrimAPI_MakeSphere_Destroy(_instance);
            _instance = IntPtr.Zero;
        }
    }
}

如果内部对象（如BRepPrim_Sphere）也需要操作，重复上述逻辑生成对应的导出函数和C#包装类即可。

方案二：使用自动绑定生成工具（推荐批量处理） #

对于大型库，手动编写导出层工作量极大，推荐使用专门的自动绑定工具：

• CppSharp：专为C到C#/VB的绑定生成设计，支持复杂C特性（继承、模板、虚函数等），可通过配置脚本批量解析库的头文件，自动生成C#包装类和对应的C++导出层。
• ClangSharp：基于Clang的绑定生成工具，适配现代C代码，能直接解析C头文件生成C#绑定。

以CppSharp为例，核心步骤：

1. 配置脚本，指定需要解析的头文件、库路径；
2. 工具自动分析C类结构，生成对应的C导出代码；
3. 同步生成完整的C#包装类，包含构造函数、成员方法、自动实现IDisposable的资源管理逻辑。

这类工具能自动处理类型适配（如Standard_Real映射到C#的double，C++对象指针映射到IntPtr或封装类），大幅减少手动工作量。

关键注意事项 #

1. 内存管理：必须保证C++端创建的对象在C#端使用完毕后被正确释放，避免内存泄漏，包装类需实现IDisposable接口。
2. 调用约定：C++导出函数默认是cdecl调用约定，C#的DllImport需显式指定CallingConvention = CallingConvention.Cdecl。
3. 类型映射：提前整理库中自定义类型与C#类型的对应关系，确保自动生成工具或手动导出时的映射准确。

内容的提问来源于stack exchange，提问作者Ibrahim Abouelseoud