Question

So I have a gigantic byte-array that represents a data packet. There’s various parts of the packet such as a header, message body, stop bits, etc. How can I create variables of the various parts of the array such that when I reference the variable I’m editing the sub-array? I’d like to use the dot notation so that referencing ByteArrayRepresentingPacket.Header would actually reference ByteArrayRepresentingPacket[0], ByteArrayRepresentingPacket.MessageBody would actually reference ByteArrayRepresentingPacket[1] through ByteArrayRepresentingPacket[8], etc. A structure seems suited for this, but how would I translate the structure into a byte-array when I need to pass it?

Answer 1

So I ended up going with a structure (like I had hoped I could). Here’s the implementation:

public struct Packet
{
    /// <summary>
    /// Constructor for initializing packet
    /// </summary>
    /// <param name="header"></param>
    /// <param name="message"></param>
    public Packet(byte[] header, byte[] message)
        : this()
    {
        this.Header = header;
        this.Message = message;
    }

    // Properties representing each part of the sub-packet parts (can be made private if needed)
    public IEnumerable<byte> Header { get; set; }
    public IEnumerable<byte> Message { get; set; }
    public IEnumerable<byte> StopBit { get { return new byte[1] { 0xFF }; } }

    /// <summary>
    /// Returns the byte representation of the whole packet
    /// </summary>
    public byte[] GetBytes
    {
        get { return Header.Concat(Message).Concat(StopBit).ToArray(); }
    }
}

I kept everything as IEnumerableso that I could just use LINQ’s .Concat operator (to make everything clean & concise). What I’m unsure of is if the performance savings I gain from using a struct (no boxing/unboxing) will be undone by using IEnumerable Properties and LINQ