声明不安全的固定自定义结构数组的解决方法

Question

对于错误CS1663（"固定大小缓冲区类型必须是以下类型之一：bool、byte、short、int、long、char、sbyte、ushort、uint、ulong、float或double。"），有什么解决方法吗？

我需要从另一个blitable自定义类型结构中声明一个不安全的固定数组，但我陷入了这个编译器错误。

显示一些代码来说明下面的问题。

struct s1
{
    byte _b1;
    byte _b2;
}
unsafe struct s2
{
    fixed s1 _s1[5]; // CS1663 here...
}

注意，这两个结构是可闪电传输的，所以这个错误对我来说没有任何意义

有人知道我能做什么吗？

谢谢。

Answer 1

另一种解决方法是使用指针类型字段。

public struct Foo
{
    public byte _b1;
    public byte _b2;
}
public unsafe struct Bar
{
    public int Length;
    public unsafe Foo* Data;
}

或者，如果您的意图是连续地创建一个包含其所有数据的单值类型对象（即，这样它就可以在非托管代码中被memcpy’d），那么唯一的方法就是完全不使用任何数组。

public struct Foo
{
    public byte _b1;
    public byte _b2;
}
public struct Bar1
{
    public Foo F1;
}
public struct Bar2
{
    public Foo F1;
    public Foo F2;
}
public struct Bar3
{
    public Foo F1;
    public Foo F2;
    public Foo F3;
}

Answer 2

这是对固定大小缓冲区的限制。

固定数组可以采用以下任何属性或修饰符允许用于常规结构成员。唯一的限制是数组类型必须是bool、byte和char，short以及int，long，sbyte、ushort或uint。

您只能使用该类型，但不能使用组合（如struct仅包含该类型）。无论您的类型是否为bittable，都没有区别。你就是不能用它。

那么就不能将自定义struct用于固定大小的缓冲区。

变通办法？嗯，是的，可能是。你可以改变你的代码结构，使用这样的东西：

unsafe struct s2
{
    fixed byte _b1[5]; 
    fixed byte _b2[5]; 
}

Answer 3

如何处理您的示例和类似的复杂性示例，首先要问自己结构是否可以简化为单个基元类型。如果可以的话，我只会通过属性或索引器访问将固定缓冲区隐藏在结构中。

在您的示例中，您有以下内容。

struct s1
{
    byte _b1;
    byte _b2;
}
unsafe struct s2
{
    fixed s1 _s1[5]; // CS1663 here...
}

如果我决定绝对需要结构在一个连续的数据块中排列，我可能会考虑这样的事情。

[StructLayout(LayoutKind.Explicit, Size = 2)]
struct s1
{   // Field offsets to emulate union style access which makes it
    // simple to get at the raw data in a primitive type format.
    [FieldOffset(0)]ushort _u1;
    [FieldOffset(0)]byte _b1;
    [FieldOffset(1)]byte _b2;
    public s1(ushort data)
    {
        _b1 = 0;
        _b2 = 0;
        _u1 = data;
    }
    public ushort ToUShort()
    {
        return _u1;
    }
}
unsafe struct s2
{
    public const int Size = 5;
    private fixed ushort _s1[Size];
    public s1 this[int index]
    {   // A public indexer that provides the data in a friendlier format.
        get
        {
            if (index < 0 || index >= Size )
                throw new IndexOutOfRangeException();
            return new s1(_s1[index]);
        }
        set
        {
            if (index < 0 || index >= Size)
                throw new IndexOutOfRangeException();
            _s1[index] = value.ToUShort();
        }
    }
}

如果这看起来像是一次黑客攻击，那是因为它有点像。我不建议将其作为一种通用解决方案，因为它很难维护，但在极少数情况下，如果你在这种低级别工作，并且事先知道数据规范不会改变，那么像这样的技术是可行的。但是，即使在这种情况下，我仍然希望尽可能多地封装这种低级别的东西，以最大限度地减少出错的可能性。也就是说，这个完全按照要求执行，这是一个解决方法，可以为自定义结构提供固定大小的缓冲区。

Answer 4

[StructLayout(LayoutKind.Sequential)]
public struct S1
{
    [MarshalAs(UnmanagedType.I1)] public byte _b1; 
    [MarshalAs(UnmanagedType.I1)] public byte _b2; 
    public S1(ushort _ushort)
    {
        this = new Converter(_ushort).s1;
    }
    public ushort USHORT() //for fixed arrays
    {
        return new Converter(this).USHORT;
    }
    [StructLayout(LayoutKind.Explicit)]
    private struct Converter
    {
        [FieldOffset(0)] public S1 s1;
        [FieldOffset(0)] public ushort USHORT;
        public Converter(S1 _s1)
        {
            USHORT = 0;
            s1 = _s1;
        }
        public Converter(ushort _USHORT)
        {
            s1 = default;
            USHORT = _USHORT;
        }
    }
}
public unsafe struct S2
{
    public fixed ushort s1[5];
    public S1 this[int n] {
        get => new S1(s1[n]); //copy!
        set => s1[n] = value.USHORT();
    }
}