如何高效传递含结构体数组的C#结构体至C++函数？

1. Marshal.PtrToStructure是否会产生拷贝？ #

是的，Marshal.PtrToStructure<T>一定会产生拷贝操作。它会将非托管内存块中的数据完整复制到新创建的托管T类型实例中，对于包含10000个元素的数组结构体来说，这会复制整个数组的所有字段，带来显著的性能开销。

2. 最小拷贝开销的最优实现方式 #

要实现最小拷贝（甚至零拷贝），核心思路是让C++直接修改托管内存中的数据，避免在托管/非托管边界之间的双向拷贝。以下是两种可行的最优方案：

方案一：使用unsafe代码直接映射托管内存（零拷贝） #

这种方式通过fixed语句固定托管结构体的内存，直接将指针传递给C函数，C修改的就是托管内存本身，完全没有拷贝开销。

步骤1：修正C#结构体定义（匹配C++布局）

注意：C#结构体不能在字段声明时直接赋值，且要确保与C++的内存布局严格一致：

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct InnerStruct
{
    public int Value1;
    public float Value2;
    public IntPtr Message; // 替换String为IntPtr，对应C++的const wchar_t*
}

[StructLayout(LayoutKind.Sequential)]
struct OuterStruct
{
    public int Count;
    // 用ByValArray匹配C++的固定大小数组布局
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10000)]
    public InnerStruct[] InnerArray;
}

步骤2：调用C++函数的零拷贝代码

// 启用unsafe代码需要在项目属性中勾选"允许不安全代码"
unsafe
{
    var outer = new OuterStruct
    {
        Count = 10000,
        InnerArray = new InnerStruct[10000]
    };

    // 预处理：将托管字符串封送到非托管内存（如果需要传递字符串给C++）
    for (int i = 0; i < outer.InnerArray.Length; i++)
    {
        outer.InnerArray[i].Message = Marshal.StringToHGlobalUni($"Item {i}");
    }

    try
    {
        // 固定托管结构体的内存，获取直接指向它的指针
        fixed (OuterStruct* outerPtr = &outer)
        {
            // 直接传递指针给C++函数，C++修改的就是托管内存
            ProcessStruct(outerPtr);
        }

        // 无需拷贝，直接使用修改后的托管结构体
        Console.WriteLine($"第5000个元素的Value1：{outer.InnerArray[5000].Value1}");
    }
    finally
    {
        // 释放之前封送的字符串内存，避免内存泄漏
        foreach (var inner in outer.InnerArray)
        {
            if (inner.Message != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(inner.Message);
            }
        }
    }
}

方案二：不使用unsafe代码，直接操作非托管内存（避免最终拷贝） #

如果项目禁用unsafe代码，可以通过Span<T>直接映射非托管内存，避免调用Marshal.PtrToStructure<T>进行完整拷贝。

调用代码示例

var outer = new OuterStruct
{
    Count = 10000,
    InnerArray = new InnerStruct[10000]
};

// 预处理字符串
for (int i = 0; i < outer.InnerArray.Length; i++)
{
    outer.InnerArray[i].Message = Marshal.StringToHGlobalUni($"Item {i}");
}

IntPtr unmanagedPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OuterStruct)));
try
{
    // 将托管结构体拷贝到非托管内存（仅一次前置拷贝）
    Marshal.StructureToPtr(outer, unmanagedPtr, false);

    // 调用C++函数修改非托管内存
    ProcessStruct(unmanagedPtr);

    // 零拷贝访问非托管内存中的数据：用Span直接映射，无需完整拷贝
    Span<OuterStruct> outerSpan = MemoryMarshal.CreateSpan(
        ref Marshal.PtrToStructure<OuterStruct>(unmanagedPtr), 
        1
    );
    // 直接访问修改后的数据
    Console.WriteLine($"第5000个元素的Value1：{outerSpan[0].InnerArray[5000].Value1}");
}
finally
{
    // 释放字符串和非托管内存
    foreach (var inner in outer.InnerArray)
    {
        if (inner.Message != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(inner.Message);
        }
    }
    Marshal.FreeHGlobal(unmanagedPtr);
}

关键注意事项 #

1. 布局一致性：必须确保C#和C++的结构体字段顺序、大小、字符集完全匹配，否则会出现内存访问错误。
2. 字符串处理：C#的string是托管类型，不能直接传递给C++的wchar_t*，必须用Marshal.StringToHGlobalUni封送到非托管内存，使用完后记得释放。
3. 内存安全：使用fixed语句时，托管内存会被固定，不会被GC移动；使用非托管内存时，必须确保在finally块中释放，避免内存泄漏。

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