Question

我已经创建了一个自定义结构来处理将被封送到GPU的RGBA值。

在我的类型中，我将单独的R，G，B和A组件保存为字节值，并且与32位无符号整数（Uint32）重叠，以便轻松传递并分配打包值。我知道这个概念是显而易见的，但这里是一个很好的衡量结构的样本：

[StructLayout(LayoutKind.Explicit, Size = 4)]
public struct RGBA
{
    [FieldOffset(0)]
    public uint32 PackedValue;

    [FieldOffset(0)]
    public byte R;

    [FieldOffset(1)]
    public byte G;

    [FieldOffset(2)]
    public byte B;

    [FieldOffset(3)]
    public byte A;
}

由于c＃处理结构的方式，必须在定义的任何构造函数中显式指定每个字段。就我而言，这意味着由于重叠字段，我必须在任何构造函数中分配两次值。

我可以使用：

public RGBA(uint packed value)
{
    R = G = B = A = 0;    //  initialize all to defaults before assigning packed value
    PackedValue = packedValue;
}

public RGBA(byte r, byte g, byte b, byte a)
{
    PackedValue = 0;    // initialize to default before assigning components
    R = r;
    G = g;
    B = b;
    A = a;
}

或者我可以首先在每个构造函数上调用基础构造函数：

public RGBA(uint packedValue) : this()
{
    PackedValue = packedValue;
}

public RGBA(byte r, byte g, byte b, byte a) : this()
{
    R = r;
    G = g;
    B = b;
    A = a;
}

由于这是用于图形代码，因此性能至关重要，我正在尝试找到在这种情况下处理构造的最佳方法。使用第一个示例似乎是两个示例的最小开销，因为虽然它涉及两次分配所有字段（一次用于PackedValue，一次用于R，G，B和A字段），另一个示例涉及分配所有值3次（在默认构造函数中两次，在定义的构造函数中一次）。

有没有办法让编译器识别出这些字段重叠，如果正在分配PackedValue，则不应要求明确指定R，G，B和A，反之亦然？我假设这可以通过手动调整生成的IL来完成，但我想知道是否有一种方法可以直接在c＃中更好地处理这个问题。

有什么想法吗？

Answer 1

来自here：

Struct成员会自动初始化为默认值。因此，无论是在构造函数中，都不需要将它们中的任何一个初始化为默认值。

但是，这不适用于您的情况。它仅适用于非重叠字段，并且仅在使用默认构造函数时才有效。无论如何，请参阅基于此的替代方案的答案的最后部分。

查看one-param构造函数的IL代码，我们可以看到编译器什么都不做（没有优化，这是带默认设置的发布模式）：

.method public hidebysig specialname rtspecialname 
        instance void  .ctor(uint32 packedValue) cil managed
{
  // Code size       42 (0x2a)
  .maxstack  6
  .locals init ([0] uint8 CS$0$0000,
           [1] uint8 CS$0$0001,
           [2] uint8 CS$0$0002)
  IL_0000:  ldarg.0
  IL_0001:  ldarg.0
  IL_0002:  ldarg.0
  IL_0003:  ldarg.0
  IL_0004:  ldc.i4.0
  IL_0005:  dup
  IL_0006:  stloc.0
  IL_0007:  stfld      uint8 ConsoleApplication2.Program/RGBA::A
  IL_000c:  ldloc.0
  IL_000d:  dup
  IL_000e:  stloc.1
  IL_000f:  stfld      uint8 ConsoleApplication2.Program/RGBA::B
  IL_0014:  ldloc.1
  IL_0015:  dup
  IL_0016:  stloc.2
  IL_0017:  stfld      uint8 ConsoleApplication2.Program/RGBA::G
  IL_001c:  ldloc.2
  IL_001d:  stfld      uint8 ConsoleApplication2.Program/RGBA::R
  IL_0022:  ldarg.0
  IL_0023:  ldarg.1
  IL_0024:  stfld      uint32 ConsoleApplication2.Program/RGBA::PackedValue
  IL_0029:  ret
} // end of method RGBA::.ctor

在@ usr的建议之后，在jitting之后它看起来是一样的（这也是发布模式，成员单独分配）：

007400B5  call        750586FE  
007400BA  mov         eax,dword ptr [ebp-8]  
007400BD  mov         byte ptr [eax],0  
                G = 0;
007400C0  mov         eax,dword ptr [ebp-8]  
007400C3  mov         byte ptr [eax+1],0  
                B = 0; 
007400C7  mov         eax,dword ptr [ebp-8]  
007400CA  mov         byte ptr [eax+2],0  
                A = 0;
007400CE  mov         eax,dword ptr [ebp-8]  
007400D1  mov         byte ptr [eax+3],0  
                PackedValue = packedValue;
007400D5  mov         eax,dword ptr [ebp-8]  
007400D8  mov         edx,dword ptr [ebp-4]  
007400DB  mov         dword ptr [eax],edx

或许对它进行基准测试是现在最好的方法。或者，使用默认构造函数并在获得struct实例后手动分配PackedValue。在这种情况下，将适用本文中描述的默认行为。

var rgba = new RGBA { PackedValue = 2556 };

OR

var rgba = new RGBA();
rgba.PackedValue = 2556;

寻求处理具有重叠字段的struct构造函数的最佳方法

1 个答案: