C# и бинарники

struct STUDENT 
{ 
public string fio; 
public string FormOfEducation; 
public int course; 
public string faculty; 
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
public struct FileRecord
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
    public char[] ID;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
    public char[] Name;

bw.Write(GetFixedSizeCharArray(s.fio, 15));//массив "чаров"
bw.Write(GetFixedSizeCharArray(s.FormOfEducation, 5));
bw.Write(s.course);
bw.Write(GetFixedSizeCharArray(s.faculty, 10));

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Windows.Forms;
 
namespace WindowsFormsApplication4
{
    public partial class Form1 : Form
    {
        class STUDENT
        {
            public string fio;
            public string FormOfEducation;
            public int course;
            public string faculty;
 
            public void Save ( BinaryWriter bw )
            {
                long old_pos = bw.BaseStream.Position;
                long ret_pos = 0L;
 
                bw.Write( 0 );
                bw.Write( fio );
                bw.Write( FormOfEducation );
                bw.Write( faculty );
                bw.Write( course );
 
                ret_pos = bw.BaseStream.Position;
                bw.BaseStream.Position = old_pos;
                bw.Write( (int)(ret_pos - old_pos - 4L) );
                bw.BaseStream.Position = ret_pos;
            }
 
            public void Load ( BinaryReader br )
            {
                br.BaseStream.Position += 4L; // пропускаем total_sz
                fio = br.ReadString();
                FormOfEducation = br.ReadString();
                faculty = br.ReadString();
                course = br.ReadInt32();
            }
        }
 
        static void SaveStudents ( List<STUDENT> items )
        {
            using ( var bw = new BinaryWriter(
                                    File.Open( "data.bin", FileMode.Create ),
                                    Encoding.Default ) )
            {
                bw.Write( items.Count );
 
                foreach ( var item in items )
                    item.Save( bw );
            }
        }
 
        static List<STUDENT> LoadStudents ( )
        {
            var lst = new List<STUDENT>();
 
            using ( var br = new BinaryReader(
                                File.Open( "data.bin", FileMode.Open ),
                                Encoding.Default ) )
            {
                int count = br.ReadInt32();
 
                for ( int i = 0; i < count; ++i )
                {
                    var stud = new STUDENT();
                    stud.Load( br );
 
                    lst.Add( stud );
                }
            }
 
            return lst;
        }
 
        static STUDENT LoadStudent ( int index )
        {
            using ( var br = new BinaryReader(
                                File.Open( "data.bin", FileMode.Open ),
                                Encoding.Default ) )
            {
                int count = br.ReadInt32();
                int currItemSz = 0;
 
                if ( count <= index )
                    return null;
 
                for ( int i = 0; i < count; ++i )
                {
                    if ( i == index )
                    {
                        var stud = new STUDENT();
                        stud.Load( br );
                        return stud;
                    }
 
                    currItemSz = br.ReadInt32();
 
                    br.BaseStream.Position += currItemSz;
                }
            }
 
            return null;
        }
 
        public Form1 ( )
        {
            InitializeComponent();
 
            if ( false )
            {
                var items = new List<STUDENT>();
 
                for ( int i = 0; i < 10; ++i )
                {
                    items.Add(
                        new STUDENT() {
                            course = i * 2,
                            faculty = "fac " + i,
                            fio = "fio " + i,
                            FormOfEducation = "foe " + i
                        } );
                }
 
                SaveStudents( items );
            }
            else
            {
                var list = LoadStudents();
                var stud = LoadStudent( 5 );
            }
        }
    }
}

    public static class StructureSerializeHelper
    {
        public static T ByteToStruct<T>(byte[] data) where T : struct 
        {
            int size = data.Length;
            IntPtr ptr = Marshal.AllocHGlobal(size);
            Marshal.Copy(data, 0, ptr, size);
            T ret = (T)Marshal.PtrToStructure(ptr, typeof(T));
            Marshal.FreeHGlobal(ptr);
            return ret;
        }
 
        public static byte[] StructToByte<T>(T val) where T : struct 
        {
            int size = Marshal.SizeOf(val);
            IntPtr ptPoint = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(val, ptPoint, true);
            byte[] bff = new byte[size];
            Marshal.Copy(ptPoint, bff, 0, size);
            Marshal.FreeHGlobal(ptPoint);
            return bff;
        }
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    struct STUDENT
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
        public string FIO;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
        public string FormOfEducation;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
        public string Faculty;
        public short Course;
 
        public STUDENT(string fio, string form, string faculty, short course)
        {
            FIO = fio;
            FormOfEducation = form;
            Faculty = faculty;
            Course = course;
        }
    }

STUDENT stud = new STUDENT("asd aaa ssss", "day", "prog", 1);
byte[] data = StructureSerializeHelper.StructToByte(stud);
using (BinaryWriter writer = new BinaryWriter(new FileStream("bin.dat", FileMode.Create)))
{
    writer.Write((short)data.Length);
    writer.Write(data);
}
STUDENT student;
using (BinaryReader reader = new BinaryReader(new FileStream("bin.dat", FileMode.Open)))
{
    int len = reader.ReadInt16();
    byte[] buffer = reader.ReadBytes(len);
    student = StructureSerializeHelper.ByteToStruct<STUDENT>(buffer);
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
  struct Test
        {
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] 
            public string Name; //20
            public ushort Field1; //1
            public byte Fiel2;  //2
            public bool Activate; //1
        }

Marshal.SizeOf(typeof(bool)) // == 4
//
        [StructLayout( LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1 )]
        struct Test
        {
            [MarshalAs( UnmanagedType.ByValTStr, SizeConst = 20 )]
            public string Name; //20
            public ushort Field1; //2
            public byte Fiel2;  //1
            public bool Activate; //4
        }

        [StructLayout( LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1 )]
        struct Test
        {
            [MarshalAs( UnmanagedType.ByValTStr, SizeConst = 20 )]
            public string Name; //20
            public ushort Field1; //2
            public byte Fiel2;  //1
            [MarshalAs( UnmanagedType.I1 )]
            public bool Activate; //1
        }