C# 反序列化ushort[]并将其填充位和字节到自定义对象

我有一个包含450多个成员的ushort[]，其中包含重复的12 bool和1字节值，如下所示：

我需要从数组中获取Person对象或从

列表中获取
ushort[]
，因此基本上我需要反序列化和序列化此
ushort[]

为了方便地解析它，我想也许我可以将它反序列化为这样的单个对象，但在它看起来很糟糕之后，我放弃了：

class Person
{
    public bool Property0 { get; set; }
    public bool Property1 { get; set; }
    public bool Property2 { get; set; }
    public bool Property3 { get; set; }
    public bool Property4 { get; set; }
    public bool Property5 { get; set; }
    public bool Property6 { get; set; }
    public bool Property7 { get; set; }
    public bool Property8 { get; set; }
    public bool Property9 { get; set; }
    public bool Property10 { get; set; }
    public bool Property11 { get; set; }
    public byte Property12 { get; set; }
}


private List<Person> Deserialize(ushort[] array)
{
    var personList = new List<Person>();
    Person person1 = new Person();
    Person person2 = new Person();
    for (int i = 0; i < array.Length; i++)
    {
        BitArray bitArray = new BitArray(array[i]);

        if (i % 3 == 0)
        {
            person1 = new Person();
            person1.Property0 = bitArray[0];
            person1.Property1 = bitArray[1];
            person1.Property2 = bitArray[2];
            person1.Property3 = bitArray[3];
            person1.Property4 = bitArray[4];
            person1.Property5 = bitArray[5];
            person1.Property6 = bitArray[6];
            person1.Property7 = bitArray[7];
            person1.Property8 = bitArray[8];
            person1.Property9 = bitArray[9];
            person1.Property10 = bitArray[10];
            person1.Property11 = bitArray[11];
        }

        if (i % 3 == 1)
        {
            byte[] bytes = new byte[1];
            bitArray.CopyTo(bytes, 0);
            person1.Property12 = bytes[0];
            
            personList.Add(person1);

            person2 = new Person();
            person2.Property0 = bitArray[0];
            person2.Property1 = bitArray[1];
            person2.Property2 = bitArray[2];
            person2.Property3 = bitArray[3];
            person2.Property4 = bitArray[4];
            person2.Property5 = bitArray[5];
            person2.Property6 = bitArray[6];
            person2.Property7 = bitArray[7];
        }

        if (i % 3 == 2)
        {
            person2.Property8 = bitArray[8];
            person2.Property9 = bitArray[9];
            person2.Property10 = bitArray[10];
            person2.Property11 = bitArray[11];

            byte[] bytes = new byte[1];
            bitArray.CopyTo(bytes, 5);
            person2.Property12 = bytes[0];

            personList.Add(person2);
        }
    }
    return personList;
}

班级人员
{
公共布尔属性0{get；set；}
公共布尔属性1{get；set；}
公共布尔属性2{get；set；}
公共布尔属性3{get；set；}
公共布尔属性4{get；set；}
公共布尔属性5{get；set；}
公共布尔属性6{get；set；}
公共布尔属性7{get；set；}
公共布尔属性8{get；set；}
公共布尔属性9{get；set；}
公共布尔属性10{get；set；}
公共布尔属性11{get；set；}
公共字节属性12{get；set；}
}
私有列表反序列化（ushort[]数组）
{
var personList=新列表（）；
Person person1=新的Person（）；
Person person2=新的Person（）；
for（int i=0；i

我怎样才能把它弄漂亮

我使用属性来序列化/反序列化json，但是库可以完成这项工作，数组反序列化有类似的功能吗

提前感谢。
如果我必须进行这种反序列化，我将使用以下方法作为开始并改进它

首先，我要将
Person
类更新为：

public class Person
{
    private readonly BitArray booleanPropertyBits;
    private readonly byte bit16To23;
    
    public Person(byte byte1, byte byte2, byte byte3)
    {
        booleanPropertyBits = new BitArray(new byte[] { byte1, byte2 });
        bit16To23 = byte3;
    }

    public bool Property0 => booleanPropertyBits[0];
    public bool Property1 => booleanPropertyBits[1];
    public bool Property2 => booleanPropertyBits[2];
    public bool Property3 => booleanPropertyBits[3];
    public bool Property4 => booleanPropertyBits[4];
    public bool Property5 => booleanPropertyBits[5];
    public bool Property6 => booleanPropertyBits[6];
    public bool Property7 => booleanPropertyBits[7];
    public bool Property8 => booleanPropertyBits[8];
    public bool Property9 => booleanPropertyBits[9];
    public bool Property10 => booleanPropertyBits[10];
    public bool Property11 => booleanPropertyBits[11];
    public byte Property12 => bit16To23;
}

之后，我将有一个helper类，它将ushort[]转换为byte[]，如：

public static class ByteStream
{
    public static IEnumerable<byte> From(ushort[] array)
    {
        foreach (var number in array)
        {
            var bytes = BitConverter.GetBytes(number);
            foreach (var b in bytes)
            {
                yield return b;
            }
        }
    }
}

公共静态类ByTestStream
{
公共静态IEnumerable From（ushort[]数组）
{
foreach（数组中的变量编号）
{
var bytes=BitConverter.GetBytes（数字）；
foreach（变量b，字节）
{
收益率b；
}
}
}
}

最后，我将使用helper方法以以下方式读取值：

private List<Person> Deserialize(ushort[] array)
{
    var bytes = ByteStream.From(array).ToArray();
    var retVal = new List<Person>();

    for (int i = 0; i < bytes.Length; i += 3)
    {
        var person = new Person(bytes[i], bytes[i + 1], bytes[i + 2]);
        retVal.Add(person);
    }

    return retVal;
}

私有列表反序列化（ushort[]数组）
{
var bytes=ByteStream.From（array.ToArray（）；
var retVal=新列表（）；
对于（int i=0；i

这不是一个完整的解决方案，但需要通过添加验证检查和一些性能调整来启动和改进。
您能更好地解释一下
ushort[]
和启动索引部分吗？抱歉，在我看来，有些片段缺失了，即使您向我们展示的代码也不能告诉我们您想要做什么。使用的
BitArray
构造函数重载创建了一个充满
false
值的实例。因此，创建它然后从中复制
false
是没有意义的。只要用值
false
和
0
填写所有
person1
和
person2
属性即可。我试图简化问题并从中删除不必要的信息，请您再次检查好吗？基本上，我只需要序列化/反序列化一个ushort[]，其中填充了12位1字节的值。同样：
new BitArray（array[I]）
创建了填充了
false
值的空BitArray。您的代码中没有使用ushort数组值。我并没有说我的代码有效，当我搜索时，我找到了BitArray并试图编写示例方法来显示我的意图以及我试图解决问题的方法。这段代码基本上意味着我在堆栈溢出中没有提出任何问题，至少没有进行研究。@Caguryay这有帮助吗？