默然的博客
TonyChenn 的游戏客户端开发博客，记录 Cocos2d-x、C#、Unity、Win32 与鸿蒙开发中的源码分析、性能优化和工程实践。
 默然的博客
facebook QQ twitter weibo telegram linkedin

C# 与 C++ 互操作：P/Invoke 函数、字符串、数组与回调

一言加载中...

发布于 更新于

1. 适用范围与结论

本文示例面向 Windows 原生 DLL，使用 C ABI、CallingConvention.Cdecl 和显式指针完成 C# 与 C++ 互操作。调用双方必须保持 CPU 架构、调用约定、字符编码、结构体布局和内存释放协议一致；仅仅能够加载 DLL，并不代表复杂参数已经安全跨过 ABI 边界。

对外接口应尽量只暴露固定宽度整数、指针和由调用方明确释放的缓冲区，不要直接把 std::string、std::vector 或带有 C++ 生命周期语义的对象布局暴露给 C#。

2. 前言

术业有专攻，当然编程语言也是这样。而不同的应用场景下单一语言或者并不能满足需求。比如：一些性能要求高的模块可以用CPP实现。常见的如游戏开发引擎，譬如Unity底层使用CPP开发，上层使用C#包装，充分利用两种语言的优势。又比如一些已有的CPP库没有对应语言的库供使用，那么互操作的重要性就体现出来了。

3. C# 与 C++ 互操作的方式

  1. P/Invoke 是可用于从托管代码访问非托管库中的结构、回调和函数的一种技术。它允许托管代码调用非托管代码。对于C#通过P/Invoke可以很方便的实现对CPP方法的调用。但是对于CPP中比较复杂的数据类型时，操作比较繁琐。

  2. C++/CLI 是微软对C++语言做的拓展，允许C++与托管语言的相互操作。非常适合处理非常复杂的数据类型和对象。但语法比较复杂，写起来比较难受，并且只支持windows平台。

  3. 比较新的方案：Mono/CoreCLR。没自己绑定过，后续研究了再补充。

  4. COM互操作，C++/WinRT 也没用过。

4. 一个简单的例子

下面是将cocos2dx中Node的getTag/setTag方法导出的一个实例。

  1. 定义一个方法，方法名最好与CPP中保持一致（当然也可以在DllImport特性中指定），参数与CPP中保持一致。
  2. 使用extern标记此方法，告诉编译器此方法在Native中实现。因此也不需要写方法体。
  3. 给当前方法加一个DllImport特性，并制定从哪里导入，和调用约定。

DllImport 的一些常用参数如下：

参数 解释
CallingConvention 指定调用约定,调用方需要与被调用方保持一致，如：Cdecl、StdCall
EntryPoint 导入的方法名
CharSet 指定字符集，确保托管字符串与非托管字符串转换时使用约定的编码，如：CharSet.Ansi、CharSet.Unicode
SetLastError 声明被调用函数会设置系统错误码，随后可通过 Marshal.GetLastWin32Error() 获取 
1
2
3
4
5
// 导入链接库xgame.dll，因为 getChildrenCount方法在xgame.dll中
[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "getTag")]
public static extern int GetTag(IntPtr node);
[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "setTag")]
public static extern void SetTag(IntPtr node, int tag);

那么C++中的导出方法该如何实现呢？

  1. extern "C" 约定使用C语言的方法生成方法名，不然导出的方法名乱七八糟，可以自行使用dumpbin查看。
  2. 使用 __declspec(dllexport)标记需要导出的方法。
1
2
3
4
5
6
7
8
9
10
11
extern "C"
{
    __declspec(dllexport) int getTag(void* obj){
        const cocos2d::Node* node = static_cast<cocos2d::Node*>(obj);
	    return node->getTag();
    }
	__declspec(dllexport) void setTag(void* obj, int tag){
        cocos2d::Node* node = static_cast<cocos2d::Node*>(obj);
	    node->setTag(tag);
    }
}

这个例子展示了int参数的传递，其他的数据类型对应如下：

C# CPP
int/float/double int/float/double
sbyte char
string char*
IntPtr void*
bool bool

这里的表格只能作为方向说明。bool 的大小和封送规则、long 的平台宽度、结构体对齐方式都可能不同；正式接口应使用 int32_t、uint32_t 等固定宽度类型，并为布尔值显式指定封送方式。

5. string 类型的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
// CPP
extern "C"
{
    __declspec(dllexport) const char* getName(void* obj){
        const cocos2d::Node* node = static_cast<cocos2d::Node*>(obj);
        const char* name = node->getName().c_str();
        return name;
    }
    __declspec(dllexport) void setName(void* obj, const char* name){
        cocos2d::Node* node = static_cast<cocos2d::Node*>(obj);
        node->setName(name);
    }
}
1
2
3
4
5
6
7
8
9
// C#
[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "getName")]
private static extern IntPtr getNameNative(IntPtr nodePtr);

[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "setName")]
private static extern void setNameNative(IntPtr nodePtr, [MarshalAs(UnmanagedType.LPStr)] string name);

public static string GetName(IntPtr node) { return Marshal.PtrToStringAnsi(getNameNative(node)); }
public static void SetName(IntPtr node, string value) { setNameNative(node, value); }

getName 返回的指针仍由 C++ 对象持有，只能在对象和名称内容保持有效时读取。需要跨线程或长期保存时，应改成“调用方提供缓冲区”或“Native 分配、Native 释放”的明确协议。

6. 数组的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
extern "C"
{
	/// <summary>
	/// 获取子节点
	/// </summary>
	/// <param name="node"></param>
	/// <param name="outPtr">子节点数组指针</param>
	/// <param name="outCount">子节点数量</param>
    __declspec(dllexport) void getChildren(cocos2d::Node* node, cocos2d::Node*** outPtr, int* outCount){
		auto& array = node->getChildren();
        int n = node->getChildrenCount();
		*outCount = n;

		*outPtr = (n == 0) ? nullptr : &(*array.begin());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern void getChildren(IntPtr node, out IntPtr data, out int count);

public unsafe static IntPtr[] GetChildren(IntPtr node)
{
	IntPtr headPtr = IntPtr.Zero;
	int childCount = 0;
	getChildren(node, out headPtr, out childCount);


	Span<IntPtr> span = (headPtr == IntPtr.Zero || childCount <= 0) ?
						Span<IntPtr>.Empty : new Span<IntPtr>((void*)headPtr, childCount);
	IntPtr[] childArray = new IntPtr[childCount];
	span.CopyTo(childArray);

	return childArray;
}

这一版直接借用 Cocos2d-x 容器内部的连续指针区，结果只在容器未发生增删和重分配时有效。C# 应立即复制，不能长期保存 headPtr；更稳妥的接口是由 Native 复制一份数组，并提供配套释放函数。

7. 自定义对象的传递

这里将子节点包装成一个对象再进行传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <cstdint>
#include <cstdlib>

extern "C"
{
    struct Cocos2dNodeArray { cocos2d::Node** data; int32_t count; };
    //CPP
    __declspec(dllexport) Cocos2dNodeArray getChildren(cocos2d::Node* node)
    {
        const cocos2d::Vector<cocos2d::Node*>& array = node->getChildren();
        const int32_t count = static_cast<int32_t>(node->getChildrenCount());
        Cocos2dNodeArray result = { nullptr, count };
        result.data = count == 0
            ? nullptr
            : static_cast<cocos2d::Node**>(malloc(count * sizeof(cocos2d::Node*)));
        if (count > 0 && result.data == nullptr)
        {
            result.count = 0;
            return result;
        }
        for (int32_t i = 0; i < count; i++)
        {
            result.data[i] = array.at(i);
        }
        return result;
    }

    __declspec(dllexport) void freeNodeArray(cocos2d::Node** data)
    {
        free(data);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// C#
[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern Cocos2dNodeArray getChildren(IntPtr node);

[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern void freeNodeArray(IntPtr data);

[StructLayout(LayoutKind.Sequential)]
public struct Cocos2dNodeArray { public IntPtr data; public int count; }

public static IntPtr[] GetChildren(IntPtr node)
{
    Cocos2dNodeArray array = getChildren(node);
    IntPtr[] ptrArray = new IntPtr[array.count];
    try
    {
        if (array.data != IntPtr.Zero && array.count > 0)
        {
            Marshal.Copy(array.data, ptrArray, 0, array.count);
        }
        return ptrArray;
    }
    finally
    {
        if (array.data != IntPtr.Zero)
        {
            freeNodeArray(array.data);
        }
    }
}

这里把数量固定为 int32_t，与 C# 的 int 保持一致，并由导出 DLL 负责释放它自己分配的内存，避免跨 CRT 或跨模块混用分配器。

8. C# 传递方法委托到 C++

这里是给cocos2dx的所有节点注入下C#的回调

1
2
3
4
5
6
7
8
9
10
11
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void OnCtorCallback(IntPtr parent, IntPtr child);

[DllImport("xgame.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "setCtorCallback")]
public static extern void SetCtorCallback(OnCtorCallback ctor);

// 注入委托
private static readonly OnCtorCallback s_onCtorCallback =
    (parentPtr, childPtr) => { /** TODO */ };

CCNativeNode.SetCtorCallback(s_onCtorCallback);

传给 Native 的委托必须由托管侧持续持有。不要只传一个随后可能被 GC 回收的临时 Lambda；建议把委托保存到静态字段或与 Native 注册生命周期一致的对象字段，并在卸载 DLL 或销毁引擎前取消回调。Native 如果从其他线程触发回调，还要保证目标运行时允许该线程进入托管环境。

CPP 中使用委托

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// CCNodeAPI.h
typedef void(*CtorCallback)(void* parent, void* child);
extern "C"
{
    __declspec(dllexport) void setCtorCallback(CtorCallback callback)
    {
        Node::setCSharpCtorCallback([callback](Node* parent, Node* child) {if (callback) callback(parent, child); });
    }
}

// cocos2dx Node.h
static std::function<void(Node*, Node*)> _onCSharpCtorCallback;

static void setCSharpCtorCallback(const std::function<void(Node*, Node*)>& callback) { _onCSharpCtorCallback = callback; }

// cocos2dx Node.cpp
// 初始化
std::function<void(Node*, Node*)> Node::_onCSharpCtorCallback = nullptr;

// 执行回调
Node * Node::create()
{
    Node * ret = new (std::nothrow) Node();
    // ...省略...
#if CC_BIND_CSHARP
    if (Node::_onCSharpCtorCallback) Node::_onCSharpCtorCallback(ret->_parent, ret);
#endif
    return ret;
}

9. 其他

9.1 为什么要使用 C ABI 导出？

本地人不小心加了命名空间，导致C#一直找不到native 方法，被坑了，通过dumpbin查看发现CPP导出的方法名比较乱，如下。
顺便记录下查看 DLL 的所有导出方法：dumpbin /EXPORTS dll_path

1
2
3
4
5
6
// 不约定的如下：
487  1E6 00472812 ?clone@Waves3D@cocos2d@@QBEPAVGrid3DAction@2@XZ = @ILT+18445(?clone@Waves3D@cocos2d@@QBEPAVGrid3DAction@2@XZ)

// 约定C语言的如下：
525  20C 0048AA8E getName = @ILT+117385(_getName)
542  21D 00478C0D setName = @ILT+44040(_setName)

10. 相关阅读

赏 支付宝 微信 关闭
Cocos2d-x 鸿蒙：ArkTS 与 C++ 双向交互 winform重定向Console日志 winform中嵌入窗体 CSharp-分部类与分部方法

评论