前置き飛ばしてタイトルの内容を見たい方はこちらから

構造体のレイアウト

環境に依存しないようなレイアウト属性を指定しておかないと、構造体情報をバイナリデータに出力してほかのPC環境で読み込むときに失敗する恐れがある。

// using System.Runtime.InteropServices; が必要
[StructLayout(LayoutKind.Sequential, Pack = 数値)]

細かく指定する場合：

// using System.Runtime.InteropServices; が必要
[StructLayout(LayoutKind.Explicit)]
struct Xxx
{
    [FieldOffset(数値)]
    byte a;
    [FieldOffset(数値)]
    int b;
}

あと、packingを2以上にした場合や、2byte以上の型のデータを扱う場合、エンディアンも気を付ける必要があるが、指定はできなさそう。

構造体に配列を持たせる／UnmanagedTypeを明示する

配列を持たせる場合、配列メンバにByValArrayと要素数を指定する。
可変長配列を持つことはできない。（構造体の実サイズが確定する必要があるためだと思われる。ポインタ的な持ち方は可能のはず。）

struct Xxx
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst=要素数)]
    int[] data;
}

変換

byte配列から構造体への変換

// using System.Runtime.InteropServices; が必要
// Xxxは任意の構造体の型名
static Xxx BytesToStruct(byte[] bytes)
{
    var gch = GCHandle.Alloc(bytes, GCHandleType.Pinned);                            // step1
    var result = (Xxx)Marshal.PtrToStructure(gch.AddrOfPinnedObject(), typeof(Xxx)); // step2
    gch.Free();                                                                      // step3
    return result;
}

step1にて、step2でアドレスを取得するためのハンドルを取得する。GCHandleType.Pinnedを指定することでピン留めしているイメージ。
なお、副作用？として、GC(ガベージコレクタ)から回収されないようにする効果があるため、step3にあるようにfree()でピン留めを外す必要がある。

Normal
This handle type represents an opaque handle, meaning you cannot resolve the address of the pinned object through the handle. You can use this type to track an object and prevent its collection by the garbage collector. This enumeration member is useful when an unmanaged client holds the only reference, which is undetectable from the garbage collector, to a managed object.
Pinned
This handle type is similar to Normal, but allows the address of the pinned object to be taken. This prevents the garbage collector from moving the object and hence undermines the efficiency of the garbage collector. Use the Free() method to free the allocated handle as soon as possible.

公式ドキュメントへのリンク
GCHandle.Alloc
Marshal.PtrToStructure

構造体からbyte配列への変換

// using System.Runtime.InteropServices; が必要
// Xxxは任意の構造体の型名
static byte[] StructToBytes(Xxx obj)
{
    int size = Marshal.SizeOf(typeof(Xxx));
    IntPtr ptr = Marshal.AllocHGlobal(size);
    Marshal.StructureToPtr(obj, ptr, false);
 
    byte[] bytes = new byte[size];
    Marshal.Copy(ptr, bytes, 0, size);
    Marshal.FreeHGlobal(ptr);
    return bytes;
}

公式ドキュメントへのリンク
typeof
Marshal.SizeOf(Type)
Marshal.AllocHGlobal(int)
Marshal.StructureToPtr
Marshal.Copy(IntPtr,byte[],int,int)
Marshal.FreeHGlobal

構造体配列を扱う

byte配列にオフセット指定して読み書きする方式で実装してみた。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct SampleStruct
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)]
    public short[] a;
}

class Sample
{
    static void CopyStructToBytes(SampleStruct obj, byte[] dest, int offset)
    {
        int size = Marshal.SizeOf(typeof(SampleStruct));
        IntPtr ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(obj, ptr, false);
    
        Marshal.Copy(ptr, dest, offset, size);
        Marshal.FreeHGlobal(ptr);
    }

    static SampleStruct BytesToStruct(byte[] bytes, int offset)
    {
        var gch = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        var result = (SampleStruct)Marshal.PtrToStructure(gch.AddrOfPinnedObject()+offset, typeof(SampleStruct));
        gch.Free();
        return result;
    }

    // 以下使用例

    static readonly int n=5;

    [STAThread]
    static void Main(string[] args)
    {
        // SampleStruct x = new SampleStruct();
        // x.a = new short[n]; // 構造体をnewで生成した時点ではaはnull扱いとなるよう。

        SampleStruct[] y = new SampleStruct[10];

        // 構造体のメンバ値を初期化
        for(int i=0;i<y.Length;i++)
        {
            y[i].a = new short[n];
            for(int k=0;k<n;k++)
            {
                y[i].a[k] = (short)(100*i+k);
            }
        }

        int sizePerElem = Marshal.SizeOf(typeof(SampleStruct));
        byte[] b = new byte[sizePerElem * y.Length];
        
        // バイト配列に変換
        for(int i=0;i<y.Length;i++) { CopyStructToBytes(y[i], b, i*sizePerElem); }

        // コンソールに出力
        for(int i=0;i<b.Length;i++) { Console.WriteLine("b[{0}] = {1}", i, b[i]); }

        // 構造体に変換（byte配列から復元）
        SampleStruct[] z = new SampleStruct[y.Length];
        for(int i=0;i<y.Length;i++) { z[i] = BytesToStruct(b, i*sizePerElem); }

        // コンソールに出力
        for(int i=0;i<y.Length;i++)
        {
            for(int k=0;k<n;k++)
            {
                Console.WriteLine("z[{0}].a[{1}] = {2}", i, k, z[i].a[k]);
            }
        }
    }
}

その他の方法

byte[]とかは管理情報を持っているので、強引に構造体⇔配列の間でキャストするのは無理そう。
ちなみに、Marshal.SizeOfに配列をぶち込むと下記のようなエラーがでます。

ハンドルされていない例外: System.ArgumentException: 型 'SampleStruct[]' はアンマネージ構造体としてマーシャリングできません。有効なサイズ、またはオフセットの計算ができません。
   場所 System.Runtime.InteropServices.Marshal.SizeOfHelper(Type t, Boolean throwIfNotMarshalable)

unsafeを使って低レイヤーでbyte列をコピーすることはおそらく可能。（速度面でどうしても必要な場合は。）

参考サイト

↓以下は古い記事なので最適な手法かは不明。考え方は参考になりそう。