如何用Marshal.OffsetOf获取嵌套结构体成员的顶层非托管偏移量

问题背景 #

需要获取嵌套结构体成员相对于顶层结构体的非托管偏移量，比如以下代码中Person结构体里Addr.Room成员相对于Person实例起始地址的偏移：

using System;
using System.Runtime.InteropServices;

struct Address
{
    public int Building;
    public int Room;
}

struct Person
{
    public int Age;
    public int Height;
    public Address Addr;
}

class OffsetTest
{
    public static void CalOffset()
    {
        // 正确获取直接成员Addr的偏移
        int offset1 = (int)Marshal.OffsetOf(typeof(Person), nameof(Person.Addr));

        // 手动累加嵌套成员偏移，结果正确但不够通用
        int offset2 = (int)Marshal.OffsetOf(typeof(Person), nameof(Person.Addr)) + 
                      (int)Marshal.OffsetOf(typeof(Address), nameof(Address.Room));

        // 直接传入嵌套路径会抛出ArgumentException
        // int offset3 = (int)Marshal.OffsetOf(typeof(Person), nameof(Person.Addr.Room));
        // int offset4 = (int)Marshal.OffsetOf(typeof(Person), "Addr.Room");
    }
}

目前通过手动累加各层级偏移（如offset2）能得到正确结果，但希望找到更通用、更优雅的实现方式，同时想知道C#中是否有类似C++里"对象地址相减"的实现思路。

核心限制 #

Marshal.OffsetOf仅支持获取当前类型的直接成员偏移，无法直接解析"Addr.Room"这类嵌套成员路径，直接传入会抛出ArgumentException。

解决方案 #

方案1：递归累加偏移量（通用封装） #

封装工具方法，递归解析嵌套成员路径，逐层累加各层级的偏移量，适配任意深度的嵌套结构体：

using System;
using System.Reflection;
using System.Runtime.InteropServices;

public static class OffsetHelper
{
    public static int GetNestedOffset(Type topLevelType, string nestedMemberPath)
    {
        string[] memberNames = nestedMemberPath.Split('.');
        Type currentType = topLevelType;
        int totalOffset = 0;

        foreach (string memberName in memberNames)
        {
            FieldInfo field = currentType.GetField(memberName, BindingFlags.Public | BindingFlags.Instance);
            if (field == null)
                throw new ArgumentException($"类型 {currentType.Name} 中找不到成员 {memberName}");

            totalOffset += (int)Marshal.OffsetOf(currentType, memberName);
            currentType = field.FieldType;
        }

        return totalOffset;
    }
}

// 使用示例
int roomOffset = OffsetHelper.GetNestedOffset(typeof(Person), "Addr.Room");

方案2：模拟C++的地址相减法 #

通过GCHandle将结构体实例固定到内存中，计算成员地址与结构体起始地址的差值，实现类似C++的偏移计算逻辑：

using System;
using System.Runtime.InteropServices;

public static class OffsetHelper
{
    public static int GetOffsetByAddressComparison<T>(Func<T, object> memberAccessor)
        where T : struct
    {
        T instance = new T();
        GCHandle handle = GCHandle.Alloc(instance, GCHandleType.Pinned);
        try
        {
            IntPtr structBasePtr = handle.AddrOfPinnedObject();
            IntPtr memberPtr = Marshal.UnsafeAddrOfPinnedArrayElement((Array)memberAccessor(instance), 0);
            return (int)(memberPtr - structBasePtr);
        }
        finally
        {
            handle.Free();
        }
    }
}

// 使用示例
int roomOffset = OffsetHelper.GetOffsetByAddressComparison<Person>(p => p.Addr.Room);

注意：此方法依赖结构体的内存布局，需确保结构体的非托管布局符合预期（默认值类型为顺序布局，与非托管内存兼容；若自定义StructLayout属性，需保证布局规则明确）。

补充说明 #

• 两种方案均支持带自定义StructLayout（如指定Pack或LayoutKind.Explicit）的结构体，因为Marshal.OffsetOf和内存地址都会遵循指定的布局规则。
• 方案1性能更优，无需分配和固定内存，适合频繁调用场景；方案2更贴近C++实现思路，直观易懂。

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