如何优雅实现byte数组元素到Pixel类数组成员变量的赋值？

我想模拟C/C++的typedef行为，自定义Pixel类统一处理像素值（当前Value为byte类型，未来可能改为uint16）。原代码通过CopyTo方法将byte数组数据复制到byte[]类型的数组中，但将目标数组改为Pixel[]后，CopyTo无法直接将byte元素赋值给Pixel类的Value成员。

目前我通过for循环手动逐个赋值，但该方法不够优雅，且不确定未来Pixel.Value改为uint16时是否适用。试过新增PixelArr类但也觉得不够优雅，希望找到更合适的实现方式。

原代码 #

private void ParseImageData()
{
    byte[] data = new byte[imageSize];

    foreach (byte[] packet in ImagePackets)// private readonly List<byte[]> ImagePackets;
    {
        byte[] datapacket = SomeFunction(packet);// private byte[] SomeFunction(byte[] imagePacket)
        datapacket.CopyTo(data, count);
        count += PACKET_SIZE;
    }
    
    // do something with Pixel type
}

临时解决方案代码 #

private void ParseImageData()
{
    Pixel[] pixels = new Pixel[imageSize];

    foreach (byte[] packet in ImagePackets)
    {
        byte[] datapacket = SomeFunction(packet);
        
        for(int i = 0; i < PACKET_SIZE; i++,count++)
        {
            pixels[i].Value = datapacket[i];
        }
    }
    // do something with Pixel type
}

现有类定义 #

public class Pixel
{
    public Pixel(byte val)
    {
        this.Value = val;
    }
    public byte Value { get; set; }
}

public class PixelArr
{
    public PixelArr(ushort size)
    {
        this.Value = new byte[size];
    }
    public byte[] Value { get; set; }
}

优化方案 #

方案1：给Pixel添加隐式转换运算符 #

通过给Pixel类添加byte到Pixel的隐式转换，让数组转换操作更简洁，且未来类型变更时只需修改转换逻辑。

修改后的Pixel类：

public class Pixel
{
    public Pixel(byte val)
    {
        Value = val;
    }

    // 新增byte到Pixel的隐式转换
    public static implicit operator Pixel(byte val)
    {
        return new Pixel(val);
    }

    // 未来改为uint16时，仅需修改此处类型及构造函数
    public byte Value { get; set; }
}

使用示例（两种方式）：

// 方式1：先收集所有byte数据再批量转换
private void ParseImageData()
{
    List<byte> allBytes = new List<byte>();
    foreach (byte[] packet in ImagePackets)
    {
        allBytes.AddRange(SomeFunction(packet));
    }
    Pixel[] pixels = allBytes.Select(b => b).ToArray();
}

// 方式2：逐包转换并复制到目标数组，接近原代码逻辑
private void ParseImageData()
{
    Pixel[] pixels = new Pixel[imageSize];
    int count = 0;
    foreach (byte[] packet in ImagePackets)
    {
        byte[] datapacket = SomeFunction(packet);
        // 利用Array.ConvertAll转换当前包的byte数组为Pixel数组，再复制
        Array.ConvertAll(datapacket, b => (Pixel)b).CopyTo(pixels, count);
        count += PACKET_SIZE;
    }
}

方案2：将Pixel改为值类型（struct），结合Span高效操作 #

如果追求极致性能，将Pixel改为struct（值类型），配合Span<T>和MemoryMarshal实现类似原代码CopyTo的高效内存复制，未来类型变更时兼容性更好。

修改后的Pixel结构体：

public struct Pixel
{
    // 直接用字段减少封装开销，也可保留属性
    public byte Value;

    // 隐式转换支持
    public static implicit operator Pixel(byte val) => new Pixel { Value = val };
}

使用示例：

private void ParseImageData()
{
    Pixel[] pixels = new Pixel[imageSize];
    // 将Pixel数组转换为byte类型的Span，直接操作内存
    Span<byte> pixelByteSpan = MemoryMarshal.Cast<Pixel, byte>(pixels.AsSpan());
    
    int count = 0;
    foreach (byte[] packet in ImagePackets)
    {
        byte[] datapacket = SomeFunction(packet);
        // 直接用Span的CopyTo完成高效复制
        datapacket.AsSpan().CopyTo(pixelByteSpan.Slice(count, PACKET_SIZE));
        count += PACKET_SIZE;
    }
}

未来将Value改为uint16时，仅需修改Pixel的Value类型为ushort，并将MemoryMarshal.Cast<Pixel, byte>改为MemoryMarshal.Cast<Pixel, ushort>，同时注意处理字节序问题（如果源数据是byte数组需要拼接为ushort）。

方案3：封装像素缓冲类（PixelBuffer） #

封装一个内部维护原始数值数组的缓冲类，对外提供Pixel的访问接口，既保留数组复制的高效性，又能统一像素类型的操作。

public class PixelBuffer
{
    // 未来可改为ushort[]
    private byte[] _innerBuffer;

    public int Length => _innerBuffer.Length;

    public PixelBuffer(int size)
    {
        _innerBuffer = new byte[size];
    }

    // 索引器：对外暴露Pixel类型的访问
    public Pixel this[int index]
    {
        get => new Pixel(_innerBuffer[index]);
        set => _innerBuffer[index] = value.Value;
    }

    // 提供高效的批量复制方法
    public void CopyFrom(byte[] source, int destIndex, int length)
    {
        Array.Copy(source, 0, _innerBuffer, destIndex, length);
    }
}

使用示例：

private void ParseImageData()
{
    PixelBuffer pixelBuffer = new PixelBuffer(imageSize);
    int count = 0;
    foreach (byte[] packet in ImagePackets)
    {
        byte[] datapacket = SomeFunction(packet);
        pixelBuffer.CopyFrom(datapacket, count, PACKET_SIZE);
        count += PACKET_SIZE;
    }
    // 访问像素示例：var pixel = pixelBuffer[0];
}

内容的提问来源于stack exchange，提问作者İpek