有没有解决错误CS1663的方法（“固定大小缓冲区类型必须是以下之一：bool、byte、short、int、long、char、sbyte、ushort、uint、ulong、float或double。”）？
我需要从另一个可平移的自定义类型结构声明一个不安全的固定数组，但我卡在了这个编译器错误上。
下面展示一些代码以阐明问题。
struct s1
{
byte _b1;
byte _b2;
}
unsafe struct s2
{
fixed s1 _s1[5]; // CS1663 here...
}
另一个解决方法是使用指针类型字段。
public struct Foo
{
public byte _b1;
public byte _b2;
}
public unsafe struct Bar
{
public int Length;
public unsafe Foo* Data;
}
如果你的意图是创建一个包含所有自己数据的单一值类型对象（即，它可以在非托管代码中进行memcpy），则唯一的方法是不使用任何数组。
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;
}
如果您能够使用C# 12（dotnet 8），那么可以使用System.Runtime.CompilerServices.InlineArray属性来创建一个结构体，以表示另一个结构体的固定大小数组，而无需进行任何指针操作。
看一下：
struct MyData
{
byte _b1;
byte _b2;
}
// We want our array to be 5 elements long, so specify a size of 5
[System.Runtime.CompilerServices.InlineArray(5)]
struct MyDataInlineArray
{
// Note that structs with the InlineArray attribute must contain
// EXACTLY one member.
MyData Element;
// In this example, this struct is now a 5-long inline array of MyData.
}
// Notice that this doesn't have to be marked unsafe anymore.
struct StructWithInlineArray
{
MyDataInlineArray myDataArray;
}
InlineArray属性来索引类型：public static void Main() {
StructWithInlineArray foo = new();
foo.myDataArray[0] = new MyData();
foo.myDataArray[1] = ...;
// You can also just use it directly
MyDataInlineArray bar = new();
bar[0] = ...;
}
这是固定大小缓冲区的限制。
固定数组可以使用任何允许用于常规结构成员的属性或修饰符。唯一的限制是数组类型必须为bool, byte, char, short, int, long, sbyte, ushort, uint, ulong, float, 或 double之一。
你只能使用这些类型，但不能组合使用（例如struct仅包含这些类型）。无论你的类型是否可位掩码，都没有区别。你只是不能使用它。
因此，你不能将自定义的struct用于固定大小缓冲区。
解决方法？嗯，也许有。你可以改变你的代码结构，并使用类似以下的内容：
unsafe struct s2
{
fixed byte _b1[5];
fixed byte _b2[5];
}
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();
}
}
}
如果这看起来像是一个黑客行为，那是因为它确实如此。我不建议将其作为一般解决方案，因为它很难维护，但在那些罕见的情况下，你在这种低级别上工作，并且事先知道数据规范不会改变，那么类似这样的技术是可行的。但即使在这些情况下，我仍然更喜欢封装尽可能多的低级别内容，以最小化出错的机会。话虽如此，这个方法确实按照要求做到了，即用于解决固定大小缓冲区的自定义结构体的问题。
[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();
}
}
struct s2 { fixed s1 s1[5]; }吗？ - Vadim Martynov