我正在尝试用 C# 优化解析器组合器。当序列化格式与内存中格式匹配时，一种可能的优化是只对要在该类型的一个实例或什至多个实例上解析的数据执行(不安全的)memcpy。

我想编写代码来确定内存格式是否与序列化格式匹配，以便动态确定是否可以应用优化。 (显然，这是一个不安全的优化，可能由于一大堆微妙的原因而无法工作。我只是在试验，不打算在生产代码中使用它。)

我使用属性 [StructLayout(LayoutKind.Sequential, Pack = 1)]强制不填充并强制内存中的顺序与声明顺序匹配。我用反射检查该属性，但实际上所有这些都确认是“无填充”。我还需要字段的顺序。 (我强烈希望不必为每个字段手动指定 FieldOffset 属性，因为那样很容易出错。)

我假设我可以使用 GetFields 返回的字段顺序，但文档明确指出订单未指定。

鉴于我使用 StructLayout 属性强制字段的顺序，有没有办法反射(reflect)该顺序？

编辑 我同意所有字段必须为 blittable 的限制.

最佳答案

如果将 LayoutKind.Sequential 与 blittable 类型一起使用，这是不必要的

您不需要使用反射或任何其他机制来找出内存中结构字段的顺序，只要所有字段都是 blittable 即可。

用 LayoutKind.Sequential 声明的结构的 blittable 字段将按照字段声明的顺序存储在内存中。这就是 LayoutKind.Sequential 的意思!

From this documentation :

For blittable types, LayoutKind.Sequential controls both the layout in managed memory and the layout in unmanaged memory. For non-blittable types, it controls the layout when the class or structure is marshaled to unmanaged code, but does not control the layout in managed memory.

请注意，这不会告诉您每个字段使用了多少填充。要找出答案，请参阅下文。

在使用 LayoutKind.Auto 时确定字段顺序，或在使用任何布局时确定字段偏移

如果您乐于使用不安全代码并且不使用反射，那么找到结构字段偏移量是相当容易的。

您只需要获取结构的每个字段的地址并计算其从结构开头的偏移量。知道每个字段的偏移量，您可以计算它们的顺序(以及它们之间的任何填充字节)。要计算用于最后一个字段(如果有)的填充字节，您还需要使用 sizeof(StructType) 获取结构的总大小。

以下示例适用于 32 位和 64 位。请注意，您不需要使用 fixed 关键字，因为该结构由于它在堆栈上而已经固定(如果您尝试使用 fixed与它):

using System;
using System.Runtime.InteropServices;

namespace Demo
{
    [StructLayout(LayoutKind.Auto, Pack = 1)]

    public struct TestStruct
    {
        public int    I;
        public double D;
        public short  S;
        public byte   B;
        public long   L;
    }

    class Program
    {
        void run()
        {
            var t = new TestStruct();

            unsafe
            {
                IntPtr p  = new IntPtr(&t);
                IntPtr pI = new IntPtr(&t.I);
                IntPtr pD = new IntPtr(&t.D);
                IntPtr pS = new IntPtr(&t.S);
                IntPtr pB = new IntPtr(&t.B);
                IntPtr pL = new IntPtr(&t.L);

                Console.WriteLine("I offset = " + ptrDiff(p, pI));
                Console.WriteLine("D offset = " + ptrDiff(p, pD));
                Console.WriteLine("S offset = " + ptrDiff(p, pS));
                Console.WriteLine("B offset = " + ptrDiff(p, pB));
                Console.WriteLine("L offset = " + ptrDiff(p, pL));

                Console.WriteLine("Total struct size = " + sizeof(TestStruct));
            }
        }

        long ptrDiff(IntPtr p1, IntPtr p2)
        {
            return p2.ToInt64() - p1.ToInt64();
        }

        static void Main()
        {
            new Program().run();
        }
    }
}

在使用 LayoutKind.Sequential 时确定字段偏移量

如果您的结构使用 LayoutKind.Sequential，那么您可以使用 Marshal.OffsetOf()直接获取偏移量，但这不适用于 LayoutKind.Auto:

foreach (var field in typeof(TestStruct).GetFields())
{
    var offset = Marshal.OffsetOf(typeof (TestStruct), field.Name);
    Console.WriteLine("Offset of " + field.Name + " = " + offset);
}

如果您使用 LayoutKind.Sequential，这显然是一种更好的方法，因为它不需要 unsafe 代码，而且它更短 - 而且您不需要需要提前知道字段的名称。正如我上面所说，不需要确定内存中字段的顺序 - 但如果您需要了解使用了多少填充，这可能会有用。

关于c# - 使用反射确定 .Net 类型在内存中的布局方式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17510042/