C# 字节[]数组到具有可变长度数组的结构

我从套接字接收一个字节数组，字节的结构只是一个固定宽度字符串的大型字符数组。在某些情况下，最后一个字段是动态的（而不是固定长度），我试图将字节封送到结构。我已经读到可变长度字符数组需要是IntPtr，但是我还没有弄清楚如何用剩余的字节封送它。我也在一些文章中读到，我可能需要第二个结构，但仍然不知道如何正确地封送它

这里有一个这样的例子

在结构中处理可变长度字符数组的正确方法是什么

结构：

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct Header
{
    #region private member fields

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f1;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f2;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f3;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f4;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f5;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f6;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    private char[] _f7;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
    private char[] _f8;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    private char[] _f9;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
    private char[] _f10;

    // how would this get filled with a char[] array from the byte array?
    public IntPtr VariableLengthData;

    #endregion
}

职能：

public static Header FromArray(byte[] array)
{
    IntPtr buff = IntPtr.Zero;

    try
    {
        int objsize = Marshal.SizeOf(typeof(Header));
        buff = Marshal.AllocHGlobal(objsize);
        Marshal.Copy(array, 0, buff, objsize);
        var result = (Header)Marshal.PtrToStructure(buff, typeof(HostHeader));

        // the variable length data needs to be filled in somehow
        // but also note that an extra 4 bytes was added to the size
        // of the struct with the IntPtr
        if(objsize < array.Length)
        {
            Marshal.Copy(array, array.Length - objsize, result.VariableLengthData, array.Length - objsize);
        }

        return result;
    }
    finally
    {
        if (buff != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(buff);
            buff = IntPtr.Zero;
        }
    }
}

来自数组的公共静态头（字节[]数组）
{
IntPtr buff=IntPtr.Zero；
尝试
{
int objsize=Marshal.SizeOf（typeof（Header））；
buff=Marshal.AllocHGlobal（objsize）；
副本（数组，0，buff，objsize）；
var result=（Header）Marshal.PtrToStructure（buff，typeof（HostHeader））；
//可变长度数据需要以某种方式填充
//但也要注意，在大小中添加了额外的4个字节
//使用IntPtr创建结构的
if（objsize

这是可行的——但现在Marshal.SizeOf（headerObj）说它比我试图将它转换回byte[]数组时实际的小。除此之外，这个解决方案有什么问题吗

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct Header
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] 
    public char[] Field1;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] 
    public char[] Field2;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] 
    public char[] Field3;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
    public char[] Field4;
}

public static Header DeserializeHeader(byte[] data)
{
    int objsize = Marshal.SizeOf(typeof(Header));
    IntPtr buff = Marshal.AllocHGlobal(objsize);
    Marshal.Copy(data, 0, buff, objsize);
    var header = (Header)Marshal.PtrToStructure(buff, typeof(Header));
    Marshal.FreeHGlobal(buff);

    // resize Field4 to hold all the remaining bytes
    if(objsize < data.Length)
    {
        header.Field4 = Encoding.ASCII.GetChars(data, objsize - header.Field4.Length, data.Length - objsize - header.Field4.Length);
    }
    return header;
}

[StructLayout（LayoutKind.Sequential，CharSet=CharSet.Ansi）]
公共结构头
{
[Marshallas（UnmanagedType.ByValArray，SizeConst=8）]
公共字符[]字段1；
[Marshallas（UnmanagedType.ByValArray，SizeConst=8）]
公共字符[]字段2；
[Marshallas（UnmanagedType.ByValArray，SizeConst=8）]
公共字符[]字段3；
[Marshallas（UnmanagedType.ByValArray，SizeConst=1）]
公共字符[]字段4；
}
公共静态头反序列化头（字节[]数据）
{
int objsize=Marshal.SizeOf（typeof（Header））；
IntPtr buff=Marshal.AllocHGlobal（objsize）；
Marshal.Copy（数据，0，buff，objsize）；
var header=（header）Marshal.PtrToStructure（buff，typeof（header））；
弗里格洛巴元帅（浅黄色）；
//调整字段4的大小以容纳所有剩余字节
if（对象大小<数据长度）
{
header.Field4=Encoding.ASCII.GetChars（data，objsize-header.Field4.Length，data.Length-objsize-header.Field4.Length）；
}
返回头；
}

只是不要试图让您的C#声明与数据包格式完全匹配。你会喜欢这个：

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
public class Header {
    //....
}

public class Packet {
    public Header Header;
    public byte[] VariableLengthData;
}

现在它变得简单了。您可以一次性封送标头，只需复制存在的任何额外字节：

static unsafe Packet FromArray(byte[] data) {
    var hdrsize = Marshal.SizeOf(typeof(Header));
    if (data.Length < hdrsize) throw new ArgumentException();
    Packet result = new Packet();
    // Marshal the header
    fixed (byte* pdata = &data[0]) {
        result.Header = (Header)Marshal.PtrToStructure(new IntPtr(pdata), typeof(Header)); 
    }
    // Copy the rest
    var varsize = data.Length - hdrsize;
    result.VariableLengthData = new byte[varsize];
    Array.Copy(data, hdrsize, result.VariableLengthData, 0, varsize);
    return result;
}

来自数组的静态不安全数据包（字节[]数据）{
var hdrsize=Marshal.SizeOf（typeof（Header））；
如果（data.Length

---

如果您认为合适，可以修改Packet类，您可能需要添加一组属性来处理char[]。

您应该重新措辞并提出一个实际问题。array+160是您的其余数据

Encoding.ASCII.GetString（array，160，array.Length-160）

@EZI-这是正确的。如果字节数组大于160，则其他所有内容都是可变长度字段。我也考虑过这个解决方案，但也读过一篇文章，其中提到使用“public fixed char Data[1]”也可以解决这个问题，但我没有完整的源代码来确定它是如何使用或封送的。为了安全起见，我可能会走这条路线，但是你知道在下面的文章中他们的意思吗？我接受了您的想法，将其作为原始结构的一部分，这可能不是最好的解决方案（例如，请参见问题），而且它似乎适用于反序列化，但将其序列化回byte[]数组，我需要对象的实际大小，而不仅仅是sizeof（头）。想法？？我考虑了一个单字节数组，但没有考虑。如果你收到一个没有额外数据的数据包，你的程序可能会因AVE而崩溃。也许你可以保证总是有一些，我不能做出同样的假设。如果我没记错的话，每个响应都有一个空终止符，所以数组的大小总是（已知数据len+1）或（已知数据len+var数据len+1）。这样，我应该能够正确封送数据而不会出现问题，并考虑已知数据len之外的任何内容，因为如果没有任何附加数据，空终止符应该填充额外的字节。然而，我仍然更喜欢您的方法，但如果尝试将其序列化为XML或JSON，肯定会让我头疼。如果您需要序列化，那么您更有理由使您的C#声明与wire格式不同。只需将头文件完全排除在外，并以您希望序列化的任何方式声明数据包即可。