15

我一直理解结构（值类型）包含结构字段中定义的字节数......但是，我做了一些测试，空结构似乎有一个例外：

public class EmptyStructTest
{
    static void Main(string[] args)
    {
        FindMemoryLoad<FooStruct>((id) => new FooStruct());
        FindMemoryLoad<Bar<FooStruct>>((id) => new Bar<FooStruct>(id));
        FindMemoryLoad<Bar<int>>((id) => new Bar<int>(id));
        FindMemoryLoad<int>((id) => id);
        Console.ReadLine();
    }

    private static void FindMemoryLoad<T>(Func<int, T> creator) where T : new()
    {
        GC.Collect(GC.MaxGeneration);
        GC.WaitForFullGCComplete();
        Thread.MemoryBarrier();
        long start = GC.GetTotalMemory(true);

        T[] ids = new T[10000];
        for (int i = 0; i < ids.Length; ++i)
        {
            ids[i] = creator(i);
        }

        long end = GC.GetTotalMemory(true);
        GC.Collect(GC.MaxGeneration);
        GC.WaitForFullGCComplete();
        Thread.MemoryBarrier();

        Console.WriteLine("{0} {1}", ((double)end-start) / 10000.0, ids.Length);
    }

    public struct FooStruct { }

    public struct Bar<T> where T : struct
    {
        public Bar(int id) { value = id; thing = default(T); }

        public int value;
        public T thing;
    }
}

如果你运行这个程序，你会发现显然有 0 字节数据的 en FooStruct 会消耗 1 字节的内存。这对我来说是个问题的原因是我想Bar<FooStruct>消耗 4 个字节（因为我要分配很多）。

为什么它有这种行为，有没有办法解决这个问题（例如，是否有一个消耗 0 字节的特殊东西——我不是在寻找重新设计）？

4

3 回答 3

11

摘要：.NET 中的空结构占用 1 个字节。您可以将其视为packing，因为未命名字节只能通过不安全代码访问。

更多信息：如果您根据 .NET 报告的值执行所有指针运算，则事情会始终如一。

以下示例说明了在堆栈上使用相邻的 0 字节结构，但这些观察显然也适用于 0 字节结构的数组。

struct z { };

unsafe static void foo()
{
    var z3 = default(z);
    bool _;
    long cb_pack, Δz, cb_raw;
    var z2 = default(z);    // (reversed since stack offsets are negative)
    var z1 = default(z);
    var z0 = default(z);

    // stack packing differs between x64 and x86
    cb_pack = (long)&z1 - (long)&z0; // --> 1 on x64, 4 on x86

    // pointer arithmetic should give packing in units of z-size
    Δz = &z1 - &z0; // --> 1 on x64, 4 on x86

    // if one asks for the value of such a 'z-size'...
    cb_raw = Marshal.SizeOf(typeof(z));     // --> 1

    // ...then the claim holds up:
    _ = cb_pack == Δz * cb_raw;     // --> true

    // so you cannot rely on special knowledge that cb_pack==0 or cb_raw==0
    _ = &z0 /* + 0 */ == &z1;   // --> false
    _ = &z0 /* + 0 + 0 */ == &z2;   // --> false

    // instead, the pointer arithmetic you meant was:
    _ = &z0 + cb_pack == &z1;   // --> true
    _ = &z0 + cb_pack + cb_pack == &z2; // --> true

    // array indexing also works using reported values
    _ = &(&z0)[Δz] == &z1;  // --> true

    // the default structure 'by-value' comparison asserts that
    // all z instances are (globally) equivalent...
    _ = EqualityComparer<z>.Default.Equals(z0, z1); // --> true

    // ...even when there are intervening non-z objects which
    // would prevent putative 'overlaying' of 0-sized structs:
    _ = EqualityComparer<z>.Default.Equals(z0, z3); // --> true

    // same result with boxing/unboxing
    _ = Object.Equals(z0, z3);  // -> true

    // this one is never true for boxed value types
    _ = Object.ReferenceEquals(z0, z0); // -> false
}

正如我在评论中提到的，@supercat 说得对，他指出：“从一开始就设计 .NET 以允许零长度结构可能不会有任何问题，但可能会出现一些问题如果它现在就开始这样做的话。”

编辑：如果您需要以编程方式区分 0 字节和 1 字节值类型，您可以使用以下内容：

public static bool IsZeroSizeStruct(Type t)
{
    return t.IsValueType && !t.IsPrimitive && 
           t.GetFields((BindingFlags)0x34).All(fi => IsZeroSizeStruct(fi.FieldType));
}

请注意，这可以正确识别总大小为零的任意嵌套结构。

[StructLayout(LayoutKind.Sequential)]
struct z { };
[StructLayout(LayoutKind.Sequential)]
struct zz { public z _z, __z, ___z; };
[StructLayout(LayoutKind.Sequential)]
struct zzz { private zz _zz; };
[StructLayout(LayoutKind.Sequential)]
struct zzzi { public zzz _zzz; int _i; };

/// ...

c = Marshal.SizeOf(typeof(z));      // 1
c = Marshal.SizeOf(typeof(zz));     // 3
c = Marshal.SizeOf(typeof(zzz));    // 3
c = Marshal.SizeOf(typeof(zzzi));   // 8

_ = IsZeroSizeStruct(typeof(z));    // true
_ = IsZeroSizeStruct(typeof(zz));   // true 
_ = IsZeroSizeStruct(typeof(zzz));  // true
_ = IsZeroSizeStruct(typeof(zzzi)); // false

[编辑：见评论]这里奇怪的是，当嵌套 0 字节结构时，单字节最小值可以累积（即 'zz' 和 'zzz' 为 3 个字节）但突然间所有的谷壳很快就消失了因为包括了一个单一的“实质性”字段。

于 2015-01-08T23:45:28.343 回答
10

这与 C（或 C++）中不允许零大小对象的原因相同：就元素数量而言的指针算术。

C# 支持不安全块中的指针减法，定义如下：

给定两个指针类型的表达式P和，该表达式计算由和给出的地址之间的差，然后将该差除以。QT*P – QPQsizeof(T)

由于除以零是不可能的，这意味着sizeof(T) > 0对于所有T.

于 2015-01-09T01:07:09.417 回答
0

这是你想要的？

.Net 1.x 中结构的空值/空值

该解决方案提到没有任何开销，我相信这就是您正在寻找的。

此外，Stroustrup 谈到了为什么结构在 C++ 中不是空的，现在语言不同了，但原理是一样的：http: //www.stroustrup.com/bs_faq2.html#sizeof-empty

于 2013-05-17T14:43:51.340 回答