C++线程式原生库与C#交互的结果返回方案优化咨询

核心思路 #

用C#委托作为回调函数，C++工作线程执行完成后直接调用该回调传递数据；同时使用CoTaskMemAlloc分配结构体内存（C#可自动释放），既避免线程冲突，又能在大型库中保持代码的可维护性。

具体实现步骤 #

1. 定义跨语言兼容的结构体 #

C++和C#必须保持一致的内存布局，显式指定对齐规则：

// C++ 头文件
#pragma pack(push, 1)
struct ResultData {
    int code;
    int value1;
    int value2;
    int count;
};
#pragma pack(pop)

// 声明回调函数类型（__stdcall匹配C#委托的调用约定）
typedef void(__stdcall* ResultCallback)(const ResultData* data);

C#端对应定义：

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct ResultData
{
    public int Code;
    public int Value1;
    public int Value2;
    public int Count;
}

// 定义与C++匹配的委托
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
public delegate void ResultCallback(IntPtr data);

2. C++ DLL实现线程创建与回调逻辑 #

• 线程创建成功后立即返回状态码（0为成功，非0为错误码）
• 线程执行完成后，用CoTaskMemAlloc分配内存（C#可通过Marshal.FreeCoTaskMem释放）
• 直接调用C#传入的回调函数传递数据

// C++ DLL 实现代码
#include <windows.h>
#include <objbase.h>

// 线程参数结构体，用于传递回调函数
struct ThreadParam {
    ResultCallback callback;
};

DWORD WINAPI WorkerThread(LPVOID lpParam) {
    ThreadParam* param = static_cast<ThreadParam*>(lpParam);
    ResultCallback callback = param->callback;
    delete param;

    // 模拟线程执行业务逻辑，生成结果
    ResultData result;
    result.code = 0;
    result.value1 = 100;
    result.value2 = 200;
    result.count = 2;

    // 分配可跨语言释放的内存
    ResultData* dataPtr = static_cast<ResultData*>(CoTaskMemAlloc(sizeof(ResultData)));
    *dataPtr = result;

    // 触发回调，将数据传递给C#
    callback(dataPtr);

    return 0;
}

// 导出函数，供C#调用创建线程
extern "C" __declspec(dllexport) int __stdcall StartWorkerThread(ResultCallback callback) {
    if (!callback) {
        return -1; // 回调为空，返回错误
    }

    ThreadParam* param = new ThreadParam();
    param->callback = callback;

    HANDLE hThread = CreateThread(nullptr, 0, WorkerThread, param, 0, nullptr);
    if (!hThread) {
        delete param;
        return GetLastError(); // 返回系统错误码
    }

    CloseHandle(hThread); // 无需保留线程句柄，直接关闭
    return 0; // 线程创建成功
}

3. C#端调用与回调处理 #

• 导入DLL导出函数
• 传递委托给C++，线程完成后接收数据并释放内存

class Program
{
    [DllImport("YourCppDll.dll", CallingConvention = CallingConvention.StdCall)]
    public static extern int StartWorkerThread(ResultCallback callback);

    static void Main(string[] args)
    {
        int status = StartWorkerThread(OnResultReceived);
        Console.WriteLine($"线程创建状态码: {status}");

        // 保持程序运行，等待线程回调
        Console.ReadLine();
    }

    static void OnResultReceived(IntPtr dataPtr)
    {
        if (dataPtr == IntPtr.Zero)
            return;

        try
        {
            ResultData result = Marshal.PtrToStructure<ResultData>(dataPtr);
            Console.WriteLine($"收到结果: 状态码={result.Code}, 值1={result.Value1}, 值2={result.Value2}, 数量={result.Count}");
        }
        finally
        {
            // 释放C++分配的内存
            Marshal.FreeCoTaskMem(dataPtr);
        }
    }
}

方案优势 #

• 无线程冲突：回调由工作线程直接触发，无需共享全局变量或队列，避免锁竞争问题
• 大型库友好：回调机制模块化，每个任务可独立定义回调类型，无需维护复杂的全局状态
• 内存安全：用CoTaskMemAlloc实现跨语言内存自动管理，避免内存泄漏或野指针
• 低耦合：C++库仅负责执行任务和触发回调，C#端负责数据处理，职责边界清晰

内容的提问来源于stack exchange，提问作者Barış Doğa Yavaş