Marshal.StructureToPtr

private static byte[] FillBytes<structure>(structure Buffer)
        {
            byte[] Ret = new byte[Marshal.SizeOf(typeof(structure))];
            var ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(structure))); // указатель
            Marshal.StructureToPtr(Buffer, ptr, false); // копируем структуру в память
            for (int i = 0; i < Ret.Length; i++) {
                Ret[i] = Marshal.ReadByte(ptr, i);
            }
 
            return Ret;
        }

        private struct _Request
        {
            public UInt16 A01_Function;
            public UInt32 A02_Direction;
            public byte A03_Request;
            public UInt16 A04_Value;
            public UInt16 A05_Index;
            public UInt32 A06_Length;
    }

[StructLayout(LayoutKind.Sequential, Pack = 1)]
private struct _Request
{
   public UInt16 A01_Function;
   public UInt32 A02_Direction;
   public byte A03_Request;
   public UInt16 A04_Value;
   public UInt16 A05_Index;
   public UInt32 A06_Length;
}

        private static byte[] FillBytes<T>(T Buffer)
        {
            int size = Marshal.SizeOf(typeof(T));
            byte[] Ret = new byte[size];
            var ptr = Marshal.AllocHGlobal(size); // указатель
            Marshal.StructureToPtr(Buffer, ptr, false); // копируем структуру в память
            Marshal.Copy(ptr, Ret, 0, Ret.Length);
            Marshal.FreeHGlobal(ptr);
            return Ret;
        }

public static byte[] GetBytes<T>(T str)
{
    int size = Marshal.SizeOf(str);
 
    byte[] arr = new byte[size];
 
    GCHandle h = default(GCHandle);
 
    try
    {
        h = GCHandle.Alloc(arr, GCHandleType.Pinned);
 
        Marshal.StructureToPtr<T>(str, h.AddrOfPinnedObject(), false);
    }
    finally
    {
        if (h.IsAllocated)
        {
            h.Free();
        }
    }
 
    return arr;
}

var handle = GCHandle.Alloc(Ret, GCHandleType.Pinned);
Marshal.StructureToPtr(Buffer, handle.AddrOfPinnedObject(), true);
handle.Free();

        private static unsafe T ToStruct<T>(this byte[] buf) where T : unmanaged
        {
            fixed (byte* ptr = buf)
            {
                return *(T*)ptr;
            }
        }
 
        private static unsafe byte[] FromStruct<T>(T str) where T : unmanaged
        {
            byte[] ret = new byte[sizeof(T)];
            fixed (byte* ptr = ret)
            {
                *(T*)ptr = str;
            }
            return ret;
        }