using System;

using System.IO;

using System.Runtime.InteropServices;

using System.Runtime.Serialization.Formatters.Binary;

public class Program

{

    /// <summary>

    /// converts byte[] to struct

    /// </summary>

    public static T RawDeserialize<T>(byte[] rawData, int position)

    {

        int rawsize = Marshal.SizeOf(typeof(T));

        if (rawsize > rawData.Length - position)

            throw new ArgumentException("Not enough data to fill struct. Array length from position: "+(rawData.Length-position) + ", Struct length: "+rawsize);

        IntPtr buffer = Marshal.AllocHGlobal(rawsize);

        Marshal.Copy(rawData, position, buffer, rawsize);

        T retobj = (T)Marshal.PtrToStructure(buffer, typeof(T));

        Marshal.FreeHGlobal(buffer);

        return retobj;

    }

​

    /// <summary>

    /// converts a struct to byte[]

    /// </summary>

    public static byte[] RawSerialize(object anything)

    {

        int rawSize = Marshal.SizeOf(anything);

        IntPtr buffer = Marshal.AllocHGlobal(rawSize);

        Marshal.StructureToPtr(anything, buffer, false);

        byte[] rawDatas = new byte[rawSize];

        Marshal.Copy(buffer, rawDatas, 0, rawSize);

        Marshal.FreeHGlobal(buffer);

        return rawDatas;

    }

    public static byte[] Serialize(Data[] t)

    {

        byte[] result;

        BinaryFormatter bF = new BinaryFormatter();

        using (MemoryStream mS = new MemoryStream())

        {

            bF.Serialize(mS, t);

            mS.Position = 0;

            result = new byte[mS.Length];

            mS.Read(result, 0, result.Length);

        }

        return result;

    }

​

    public static Data[] Deserialize(byte[] buffer)

    {

        Data[] result;

        BinaryFormatter bf = new BinaryFormatter();

        using (MemoryStream mS = new MemoryStream())

        {

            mS.Write(buffer, 0, buffer.Length);

            mS.Position = 0;

            result =   (Data[])bf.Deserialize(mS);

        }

        return result;

    }

    [Serializable]

    [StructLayout(LayoutKind.Sequential, Pack = 1)]

    public struct MyStruct

    {

        public byte b;

        public ushort s;

    }

    [Serializable]

    [StructLayout(LayoutKind.Sequential, Pack = 1)]

    public struct Data

    {

        public byte b;

        public ushort s;

        public MyStruct[] arr;

    }

    public static void Main()

    {

        Data d = new Data();

        d.b = 1;

        d.s = 2;

        d.arr = new MyStruct[] 

        { 

            new MyStruct(){ b = 4, s = 8 },

            new MyStruct(){ b = 16, s = 32 }

        };

        //var bytes = RawSerialize(d);

        var bytes = Serialize(new Data[] { d });

        Console.WriteLine("Total size should be: " + (Marshal.SizeOf(d) + (Marshal.SizeOf(d.arr[0]) * 2)));

        Console.WriteLine("Total size: " + bytes.Length);

        foreach (var b in bytes)

            Console.Write(b);

    }

}