Чтение структуры из бинарного файла

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
        public struct str_pereval
        {
 
            public int nk;
            public int N_vn, N_vv;
            public Single d_vn, d_vv;
            public DateTime t_n;
            public DateTime t_k;
            public Single L;
            public Single P, Pm, Pp;
            public Single kal_n, kal_v;
            public Single[] res_v;
            public Single[] frez;
            public int[] irez;
 
            str_pereval(int size)
                : this()
            {
                frez = new float[size];
                irez = new int[size];
            }
            };
 
public class FileOperations
{
    str_pereval per = new str_pereval();
 
    public FileOperations()
    { this.per.nk = 1; }
 
    public void Read()
    {
        using (BinaryReader br = new BinaryReader(new FileStream("fpereval.dat", FileMode.Open)))
           this.per = br.ReadStruct <str_pereval>();
   }
}
public static class BinaryOperationExtension
{
    public static T ReadStruct<T>(BinaryReader reader) where T : struct
    {
        byte[] rawData = reader.ReadBytes(Marshal.SizeOf(typeof(T)));
        GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
        var returnObject = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();
        return returnObject;
    }
}
    }
    
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Drawing;
using System.Globalization;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
 
namespace ArcNew
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
          //  str_pereval.FileOperations rr = new str_pereval.FileOperations();
         //   rr.Read();
 
 
            DateTime dt = new DateTime();
            String[] format = new String[] { "ddMMyy" };
            String S, S1;
 
            dt = this.dateTimePicker1.Value;
            for (int i = 0; i < format.Length; i++)
            {
                S = dt.ToString(format[i], DateTimeFormatInfo.CurrentInfo);
                int Nsm = Convert.ToInt32(numericUpDown1.Value);
                /**/
                S1 = S;
                S = "s" + S;
                S = S + "_" + Nsm + ".dat";
 
                S1 = "d" + S1;
                S1 = S1 + "_" + Nsm + ".dat";
 
                String managedString = S1;
                var Nd = Marshal.StringToHGlobalAnsi(managedString);
 
 
                String managedStringg = S;
                var Ns = Marshal.StringToHGlobalAnsi(managedStringg);
            }
 
 
            for (int i = 0; i <= 3; i++)
            {
                dataGridView1.Rows.Add();
                dataGridView1.Rows[i].Cells[0].Value = (i + 1).ToString();
            }
           
           
             var list = new List<str_pereval>();
        using (var reader = new BinaryReader(File.OpenRead("fpereval.dat")))
        {
            while (reader.BaseStream.Position != reader.BaseStream.Length)
            {
                var obj2 = reader.ReadStruct<str_pereval>();
                list.Add(obj2);
            }
        }
 
 
        }
    }
 //================================
 
            
    
 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
public struct str_pereval
    {
        
 
        public int nk;
        public int N_vn, N_vv;
        public Single d_vn, d_vv;
        public DateTime t_n;
        public DateTime t_k;
        public Single L;
        public Single P, Pm, Pp;
        public Single kal_n, kal_v;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public float[] res_v;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public float[] frez;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public int[] irez;
     /*   public Single[] res_v;
       public Single[] frez;
       public int[] irez;
 
       str_pereval(int size)
           : this()
        {
           frez = new float[size];
           irez = new int[size];*/
        }
 
 
 
  /**/ public static class BinaryOperationExtension
    {
        public static T ReadStruct<T>(this BinaryReader reader) where T : struct
        {
 
 
            byte[] rawData = reader.ReadBytes(Marshal.SizeOf(typeof(T)));
            GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
            var returnObject = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
            handle.Free();
            return returnObject;
        
        }
    
    } /**/
 
 
       
    }

this.per = br.ReadStruct <str_pereval>();

  //public DateTime t_n;
    //public DateTime t_k;

 public DateTime t_n;
 public DateTime t_k;

public struct str_pereval
{  public int nk;
    public int N_vn, N_vv;
    public Single d_vn, d_vv;
    public DateTime t_n;
    public DateTime t_k;
    public Single L;
    public Single P, Pm, Pp;
    public Single kal_n, kal_v;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public float[] res_v;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public float[] frez;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public int[] irez;
}

[StructLayout(LayoutKind.Sequential)]
public struct str_pereval
{
    public int nk;
    public int N_vn, N_vv;
    public float d_vn, d_vv;
    public DateTime t_n;
    public DateTime t_k;
    public float L;
    public float P, Pm, Pp;
    public float kal_n, kal_v;
    public float res_v;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    public float[] frez;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    public int[] irez;
};

public float[] Frez => frez;
        public int[] Irez => irez;

public ObservableCollection<str_pereval> List { get; private set; } = new ObservableCollection<str_pereval>();

public float[] Frez => frez;

public float[] Frez { get { frez return frez; } }

public ObservableCollection<str_pereval> List { get; private set; } = new ObservableCollection<str_pereval>();

public ObservableCollection<str_pereval> List { get; private set; }
 
public MainWindow()
{
     List = new ObservableCollection<str_pereval>();
}

 public float[] Frez { get { frez return frez; } }
        public int[] Irez {get { irez return irez;}}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace WpfApplication1
{
    [StructLayout(LayoutKind.Sequential)]
    public class str_pereval
    {
        public int nk       { get; set; }
        public int N_vn     { get; set; }
        public int N_vv     { get; set; }
        public float d_vn   { get; set; }
        public float d_vv   { get; set; }
        public DateTime t_n { get; set; }
        public DateTime t_k { get; set; }
        public float L      { get; set; }
        public float P      { get; set; }
        public float Pm     { get; set; }
        public float Pp     { get; set; }
        public float kal_n  { get; set; }
        public float kal_v  { get; set; }
        public float res_v  { get; set; }
 
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        private float[] frez;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        private int[] irez;
 
        public float[] Frez {get{return  frez;}}
        public int[] Irez { get { return irez; } }
    };
 
    public partial class MainWindow : Window
    {
        public ObservableCollection<str_pereval> List { get; private set; } 
        public MainWindow()
        {
           List = new ObservableCollection<str_pereval>();
 
            InitializeComponent();
            DataContext = List;
            CommandBinding_Open_Executed(null, null);
        }
 
        private void CommandBinding_Open_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            List.Clear();
            using (var reader = new BinaryReader(File.OpenRead("fpereval.dat")))
            {
                while (reader.BaseStream.Position != reader.BaseStream.Length)
                {
                    var obj = ReadStruct<str_pereval>(reader);
                    List.Add(obj);
                }
            }
        }
 
        private void CommandBinding_Save_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            using (var writer = new BinaryWriter(File.Open("fpereval.dat", FileMode.Create)))
            {
                foreach (var obj in List)
                    WriteStruct(writer, obj);
                writer.Flush();
            }
        }
 
        private void CommandBinding_Close_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            Application.Current.Shutdown();
        }
 
        T ReadStruct<T>(BinaryReader reader) where T : class, new()
        {
            byte[] rawData = reader.ReadBytes(Marshal.SizeOf(typeof(T)));
            GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
            var returnObject = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
            handle.Free();
            return returnObject;
        }
 
        void WriteStruct<T>(BinaryWriter Writer, T value) where T : class, new()
        {
            int rawsize = Marshal.SizeOf(typeof(T));
            IntPtr buffer = Marshal.AllocHGlobal(rawsize);
            Marshal.StructureToPtr(value, buffer, false);
            byte[] rawdatas = new byte[rawsize];
            Marshal.Copy(buffer, rawdatas, 0, rawsize);
            Marshal.FreeHGlobal(buffer);
            Writer.Write(rawdatas);
        }
    }
}