title: System.OutOfMemoryExeption C#
body: <p>When I'm running my application and load a file(25MB) through it, everything runs just fine.</p>
  
  <p>But when I try loading a file(160MB) I get a <code>System.OutOfMemoryExeption</code>.
  Although I have been able to load the larger file at some point in time.</p>
  
  <p>Is there anyway to fix this? If so, any help would be much appreciated!</p>
  
  <p>My Code that loads the files:</p>
  
  <pre><code>private void openFile (string fileName)
      {
          List&lt;Structs.strValidData&gt; _header1 = new List&lt;Structs.strValidData&gt;();
          List&lt;Structs.strValidData&gt; _header2 = new List&lt;Structs.strValidData&gt;();
          List&lt;Structs.strValidData&gt; _header3 = new List&lt;Structs.strValidData&gt;();
          List&lt;Structs.strValidData&gt; _header4 = new List&lt;Structs.strValidData&gt;();
  
          var textBoxArray = new[]
                  {
                      textBoxResStart_Status1,
                      textBoxResStart_Status2,
                      textBoxResStart_Status3,
                      textBoxResStart_Status4,
                      textBoxResStart_Status5,
                      textBoxResStart_Status6,
                      textBoxResStart_Status7,
                      textBoxResStart_Status8,
                  };
  
          var radioButtonArray = new[]
                  {
                      radioButtonResStart_SelectStr1,
                      radioButtonResStart_SelectStr2,
                      radioButtonResStart_SelectStr3,
                      radioButtonResStart_SelectStr4,
                      radioButtonResStart_SelectStr5,
                      radioButtonResStart_SelectStr6,
                      radioButtonResStart_SelectStr7,
                      radioButtonResStart_SelectStr8,
                  };
  
          readCSV read;
          read = new readCSV();
  
          strInfo = default(Structs.strInfo);
          strData = default(Structs.strData);
          strSetup = default(Structs.strSetup);
          strValidData = new List&lt;Structs.strValidData&gt;();
          readID = default(Structs.ReadID);
  
          try
          {
              strInfo = read.loadInfo(fileName);
              strData = read.loadData(fileName);
              strSetup = read.loadSetup(fileName);
              readID = read.loadID(fileName);
  
              strValidData = read.loadValidData(fileName);
  
              var Str1 = read.loadStr1(fileName);
              var Str235678 = read.loadStr235678(fileName);
              var Str4 = read.loadStr4(fileName);
  
              foreach (Structs.strValidData items in strValidData)
              {
                  if (items.Str1_ValidData == true)
                  {
                      Str1_headers.Add(items);
                  }
  
                  if (items.Str2_ValidData == true ||
                      items.Str3_ValidData == true ||
                      items.Str5_ValidData == true ||
                      items.Str6_ValidData == true ||
                      items.Str7_ValidData == true ||
                      items.Str8_ValidData == true)
                  {
                      Str235678_headers.Add(items);
                  }
  
                  if (items.Str4_ValidData == true)
                  {
                      Str4_headers.Add(items);
                  }
              }
  
              Str1_data = combineData(Str1, Str1_headers);
              Str4_data = combineData(Str4, Str4_headers);
              var Str235678_CombinedData = combineData(Str235678, Str235678_headers);
  
  
              foreach (Structs.strValidData items in Str235678_CombinedData)
              {
                  if (items.Str2_ValidData == true)
                  {
                      Str2_data.Add(items);
                  }
                  if (items.Str3_ValidData == true)
                  {
                      Str3_data.Add(items);
                  }
                  if (items.Str5_ValidData == true)
                  {
                      Str5_data.Add(items);
                  }
                  if (items.Str6_ValidData == true)
                  {
                      Str6_data.Add(items);
                  }
                  if (items.Str7_ValidData == true)
                  {
                      Str7_data.Add(items);
                  }
                  if (items.Str8_ValidData == true)
                  {
                      Str8_data.Add(items);
                  }
  
              }
  
              strInfo = read.loadInfo(openDialog.FileName);
              strData = read.loadData(openDialog.FileName);
              strSetup = read.loadSetup(openDialog.FileName);
              readID = read.loadID(openDialog.FileName);
  
          }
  
          catch (Exception err)
          {
              MessageBox.Show(err.Message);
              error.logSystemError(err);
          }
      }
  </code></pre>
  
  <p>Here are the <code>ReadCSV()</code> code:</p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.Windows.Forms;
  using FileHelpers;
  using FileHelpers.Events;
  
  namespace Reading_Files
  {
  
  
  public class readCSV
  {
  
      public int strCnt = 0;
      private readCSVprogressForm _waitForm;
  
      public List&lt;Structs.strDataImport&gt; copyList(List&lt;strData&gt; copyFrom)
      {
          List&lt;Structs.strDataImport&gt; list = new List&lt;Structs.strDataImport&gt;();
  
          list.AddRange(copyFrom.Select(s =&gt; copyListContents(s)));
  
          return list;
      }
  
      public Structs.strDataImport copyListContents(strData copyFrom)
      {
          Structs.strDataImport data = new Structs.strDataImport();
          data.sCD_TimeCP2711 = copyFrom.sCD_TimeCP2711;
          data.sCD_TimeCX9020_1 = copyFrom.sCD_TimeCX9020_1;
          data.sCD_TimeCX9020_2 = copyFrom.sCD_TimeCX9020_2;
          data.rCD_CX9020_1_TimeDiff_DataLow = (Int32)(copyFrom.rCD_CX9020_1_TimeDiff_DataLow);
          data.rCD_CX9020_2_TimeDiff_DataLow = (Int32)(copyFrom.rCD_CX9020_2_TimeDiff_DataLow);
          data.iCD_NumUpper = copyFrom.iCD_NumUpper;
          data.iCD_NumUpper = copyFrom.iCD_NumUpper;
          data.iCD_NumLower = copyFrom.iCD_NumLower;
          data.iCD_NumLower = copyFrom.iCD_NumLower;
  
          data.bCD_1_Status = copyFrom.bCD_1_Status;
          data.bCD_1_Overrange = copyFrom.bCD_1_Overrange;
          data.iCD_1_Str_ID = copyFrom.iCD_1_Str_ID;
          data.rCD_1_Value = copyFrom.rCD_1_Value;
  
          data.bCD_2_Status = copyFrom.bCD_2_Status;
          data.bCD_2_Overrange = copyFrom.bCD_2_Overrange;
          data.iCD_2_Str_ID = copyFrom.iCD_2_Str_ID;
          data.rCD_2_Value = copyFrom.rCD_2_Value;
  
          data.bCD_3_Status = copyFrom.bCD_3_Status;
          data.bCD_3_Overrange = copyFrom.bCD_3_Overrange;
          data.iCD_3_Str_ID = copyFrom.iCD_3_Str_ID;
          data.iCD_3_RawData = copyFrom.iCD_3_RawData;
          data.rCD_3_Value = copyFrom.rCD_3_Value;
  
          data.bCD_4_Status = copyFrom.bCD_4_Status;
          data.bCD_4_Overrange = copyFrom.bCD_4_Overrange;
          data.iCD_4_Str_ID = copyFrom.iCD_4_Str_ID;
          data.iCD_4_RawData = copyFrom.iCD_4_RawData;
          data.rCD_4_Value = copyFrom.rCD_4_Value;
  
          data.bCD_5_Status = copyFrom.bCD_5_Status;
          data.bCD_5_Overrange = copyFrom.bCD_5_Overrange;
          data.iCD_5_Str_ID = copyFrom.iCD_5_Str_ID;
          data.iCD_5_RawData = copyFrom.iCD_5_RawData;
          data.rCD_5_Value = copyFrom.rCD_5_Value;
  
          data.bCD_6_Status = copyFrom.bCD_6_Status;
          data.bCD_6_Overrange = copyFrom.bCD_6_Overrange;
          data.iCD_6_Str_ID = copyFrom.iCD_6_Str_ID;
          data.iCD_6_RawData = copyFrom.iCD_6_RawData;
          data.rCD_6_Value = copyFrom.rCD_6_Value;
  
          data.bCD_7_Status = copyFrom.bCD_7_Status;
          data.bCD_7_Overrange = copyFrom.bCD_7_Overrange;
          data.iCD_7_Str_ID = copyFrom.iCD_7_Str_ID;
          data.iCD_7_RawData = copyFrom.iCD_7_RawData;
          data.rCD_7_Value = copyFrom.rCD_7_Value;
  
          data.bCD_8_Status = copyFrom.bCD_8_Status;
          data.bCD_8_Overrange = copyFrom.bCD_8_Overrange;
          data.iCD_8_Str_ID = copyFrom.iCD_8_Str_ID;
          data.iCD_8_RawData = copyFrom.iCD_8_RawData;
          data.rCD_8_Value = copyFrom.rCD_8_Value;
  
          data.bCD_9_Status = copyFrom.bCD_9_Status;
          data.bCD_9_Overrange = copyFrom.bCD_9_Overrange;
          data.iCD_9_Str_ID = copyFrom.iCD_9_Str_ID;
          data.iCD_9_RawData = copyFrom.iCD_9_RawData;
          data.rCD_9_Value = copyFrom.rCD_9_Value;
  
          data.bCD_10_Status = copyFrom.bCD_10_Status;
          data.bCD_10_Overrange = copyFrom.bCD_10_Overrange;
          data.iCD_10_Str_ID = copyFrom.iCD_10_Str_ID;
          data.iCD_10_RawData = copyFrom.iCD_10_RawData;
          data.rCD_10_Value = copyFrom.rCD_10_Value;
  
          data.bCD_11_Status = copyFrom.bCD_11_Status;
          data.bCD_11_Overrange = copyFrom.bCD_11_Overrange;
          data.iCD_11_Str_ID = copyFrom.iCD_11_Str_ID;
          data.iCD_11_RawData = copyFrom.iCD_11_RawData;
          data.rCD_11_Value = copyFrom.rCD_11_Value;
  
          data.bCD_12_Status = copyFrom.bCD_12_Status;
          data.bCD_12_Overrange = copyFrom.bCD_12_Overrange;
          data.iCD_12_Str_ID = copyFrom.iCD_12_Str_ID;
          data.iCD_12_RawData = copyFrom.iCD_12_RawData;
          data.rCD_12_Value = copyFrom.rCD_12_Value;
  
          data.bCD_13_Status = copyFrom.bCD_13_Status;
          data.bCD_13_Overrange = copyFrom.bCD_13_Overrange;
          data.iCD_13_Str_ID = copyFrom.iCD_13_Str_ID;
          data.iCD_13_RawData = copyFrom.iCD_13_RawData;
          data.rCD_13_Value = copyFrom.rCD_13_Value;
  
          data.bCD_14_Status = copyFrom.bCD_14_Status;
          data.bCD_14_Overrange = copyFrom.bCD_14_Overrange;
          data.iCD_14_Str_ID = copyFrom.iCD_14_Str_ID;
          data.iCD_14_RawData = copyFrom.iCD_14_RawData;
          data.rCD_14_Value = copyFrom.rCD_14_Value;
  
          data.bCD_15_Status = copyFrom.bCD_15_Status;
          data.bCD_15_Overrange = copyFrom.bCD_15_Overrange;
          data.iCD_15_Str_ID = copyFrom.iCD_15_Str_ID;
          data.iCD_15_RawData = copyFrom.iCD_15_RawData;
          data.rCD_15_Value = copyFrom.rCD_15_Value;
  
          data.bCD_16_Status = copyFrom.bCD_16_Status;
          data.bCD_16_Overrange = copyFrom.bCD_16_Overrange;
          data.iCD_16_Str_ID = copyFrom.iCD_16_Str_ID;
          data.iCD_16_RawData = copyFrom.iCD_16_RawData;
          data.rCD_16_Value = copyFrom.rCD_16_Value;
  
          data.bCD_17_Status = copyFrom.bCD_17_Status;
          data.bCD_17_Overrange = copyFrom.bCD_17_Overrange;
          data.iCD_17_Str_ID = copyFrom.iCD_17_Str_ID;
          data.iCD_17_RawData = copyFrom.iCD_17_RawData;
          data.rCD_17_Value = copyFrom.rCD_17_Value;
  
          data.bCD_18_Status = copyFrom.bCD_18_Status;
          data.bCD_18_Overrange = copyFrom.bCD_18_Overrange;
          data.iCD_18_Str_ID = copyFrom.iCD_18_Str_ID;
          data.iCD_18_RawData = copyFrom.iCD_18_RawData;
          data.rCD_18_Value = copyFrom.rCD_18_Value;
  
          data.bCD_19_Status = copyFrom.bCD_19_Status;
          data.bCD_19_Overrange = copyFrom.bCD_19_Overrange;
          data.iCD_19_Str_ID = copyFrom.iCD_19_Str_ID;
          data.rCD_19_Value = copyFrom.rCD_19_Value;
  
          data.bCD_20_Status = copyFrom.bCD_20_Status;
          data.bCD_20_Overrange = copyFrom.bCD_20_Overrange;
          data.iCD_20_Str_ID = copyFrom.iCD_20_Str_ID;
          data.rCD_20_Value = copyFrom.rCD_20_Value;
  
          return data;
      }
  
      public Structs.ReaStrID load_ID(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strID),
                              typeof(strData));
  
          engine.RecordSelector = new RecordTypeSelector(strIDSelector);
          var data = engine.ReadFile(FileName);
  
          Structs.ReaStrID structure = new Structs.ReaStrID();
          foreach (strID filteredData in data)
          {
              structure.steID[0] = filteredData._1_Ste_ID;
              structure.Status[0] = filteredData._1_Status;
              structure.steID[1] = filteredData._2_Ste_ID;
              structure.Status[1] = filteredData._2_Status;
              structure.steID[2] = filteredData._3_Ste_ID;
              structure.Status[2] = filteredData._3_Status;
              structure.steID[3] = filteredData._4_Ste_ID;
              structure.Status[3] = filteredData._4_Status;
              structure.steID[4] = filteredData._5_Ste_ID;
              structure.Status[4] = filteredData._5_Status;
          }
  
          return structure;
      }
  
      public Structs.strInfo loadInfo(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strID),
                              typeof(strData));
  
          engine.RecordSelector = new RecordTypeSelector(strInfoSelector);
          var data = engine.ReadFile(FileName);
  
          Structs.strInfo structure = new Structs.strInfo();
          foreach (strInfo filteredData in data)
          {
              structure.Date = filteredData.Date;
              structure.Description1 = filteredData.Description1;
              structure.Description2 = filteredData.Description2;
              structure.Description3 = filteredData.Description3;
          }
  
          return structure;
      }
  
      public Structs.strData loadData(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strID),
                              typeof(strData));
  
          engine.RecordSelector = new RecordTypeSelector(strDataSelector);
          var data = engine.ReadFile(FileName);
  
          Structs.strData structure = new Structs.strData();
          foreach (strData filteredData in data)
          {
              structure.iMDstr_var1_TypeID = filteredData.iMDstr_var1_TypeID;
              structure.rMDstr_var1_Lenght = filteredData.rMDstr_var1_Lenght;
              structure.iMDstr_var2_TypeID = filteredData.iMDstr_var2_TypeID;
              structure.rMDstr_var2_Lenght = filteredData.rMDstr_var2_Lenght;
              structure.iMDstr_var3_TypeID = filteredData.iMDstr_var3_TypeID;
              structure.rMDstr_var3_Lenght = filteredData.rMDstr_var3_Lenght;
              structure.iMDstr_var4_TypeID = filteredData.iMDstr_var4_TypeID;
              structure.rMDstr_var4_Lenght = filteredData.rMDstr_var4_Lenght;
  
          }
  
          return structure;
      }
  
      public Structs.strSetup loadSetup(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strID),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strData));
  
          engine.RecordSelector = new RecordTypeSelector(strSetupSelector);
          var data = engine.ReadFile(FileName);
  
          Structs.strSetup structure = new Structs.strSetup();
  
          foreach (strSetup filteredData in data)
          {
              structure.sSSstr_Sens = filteredData.sSSstr_Sens;
              structure.bSSstr_S1_A = filteredData.bSSstr_S1_A;
              structure.iSSstr_S1_B = filteredData.iSSstr_S1_B;
              structure.sSSstr_S1_C = filteredData.sSSstr_S1_C;
              structure.rSSstr_S1_D = filteredData.rSSstr_S1_D;
              structure.bSSstr_S2_A = filteredData.bSSstr_S2_A;
              structure.iSSstr_S2_B = filteredData.iSSstr_S2_B;
              structure.sSSstr_S2_C = filteredData.sSSstr_S2_C;
              structure.rSSstr_S2_D = filteredData.rSSstr_S2_D;
              structure.bSSstr_S3_A = filteredData.bSSstr_S3_A;
              structure.iSSstr_S3_B = filteredData.iSSstr_S3_B;
              structure.sSSstr_S3_C = filteredData.sSSstr_S3_C;
              structure.iSSstr_S3_D = filteredData.iSSstr_S3_D;
          }
          return structure;
      }
  
      public List&lt;Structs.str1&gt; load1(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strData),
                              typeof(strID),
                              typeof(strValidData),
                              typeof(strStartNum),
                              typeof(str1),
                              typeof(str4));
  
          engine.RecordSelector = new RecordTypeSelector(str1Selector);
          var data = engine.ReadFile(FileName);
  
          List&lt;Structs.str1&gt; list = new List&lt;Structs.str1&gt;();
          int i = 0;
          foreach (str1 data1 in data)
          {
              Structs.str1 structure = new Structs.str1();
              structure.rGL_1_L_Positive = data1.rGL_1_L_Positive;
              structure.rGL_1_L_Negative = data1.rGL_1_L_Negative;
              structure.rGL_1_R_Positive = data1.rGL_1_R_Positive;
              structure.rGL_1_R_Negative = data1.rGL_1_R_Negative;
  
              list.Add(structure);
              i++;
          }
  
          return list;
      }
  
      public List&lt;Structs.str4&gt; load4(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strData),
                              typeof(strValidData),
                              typeof(strStartNum),
                              typeof(str1),
                              typeof(str4));
  
          engine.RecordSelector = new RecordTypeSelector(str4Selector);
          var data = engine.ReadFile(FileName);
  
          List&lt;Structs.str4&gt; list = new List&lt;Structs.str4&gt;();
          int i = 0;
          foreach (str4 data4 in data)
          {
              Structs.str4 structure = new Structs.str4();
  
              structure.rGL_4_1 = data4.rGL_4_1;
              structure.rGL_4_2 = data4.rGL_4_2;
              structure.rGL_4_3 = data4.rGL_4_3;
              structure.rGL_4_4 = data4.rGL_4_4;
              structure.rGL_4_5 = data4.rGL_4_5;
              structure.rGL_4_6 = data4.rGL_4_6;
              structure.rGL_4_7 = data4.rGL_4_7;
              structure.rGL_4_8 = data4.rGL_4_8;
  
              list.Add(structure);
              i++;
          }
  
          return list;
      }
  
      public List&lt;Structs.strValidData&gt; loadValidData(string FileName)
      {
          var engine = new MultiRecordEngine(typeof(strInfo),
                              typeof(strData),
                              typeof(strSetup),
                              typeof(strID),
                              typeof(strData),
                              typeof(strValidData));
  
          engine.RecordSelector = new RecordTypeSelector(strValidDataSelector);
          var data = engine.ReadFile(FileName);
  
          List&lt;Structs.strValidData&gt; list = new List&lt;Structs.strValidData&gt;();
          int i = 0;
          foreach (strValidData strValidData in data)
          {
              Structs.strValidData structure = new Structs.strValidData();
              structure._name = String.Format("strItem {0}", i + 1);
              structure._index = i;
              structure.str1_ValidData = strValidData.str1_ValidData;
              structure.str2_ValidData = strValidData.str2_ValidData;
              structure.str3_ValidData = strValidData.str3_ValidData;
              structure.str4_ValidData = strValidData.str4_ValidData;
              structure.str5_ValidData = strValidData.str5_ValidData;
              structure.str6_ValidData = strValidData.str6_ValidData;
              structure.str7_ValidData = strValidData.str7_ValidData;
              structure.str8_ValidData = strValidData.str8_ValidData;
              structure.str9_ValidData = strValidData.str9_ValidData;
              list.Add(structure);
              i++;
          }
  
          return list;
      }
  
      public List&lt;List&lt;Structs.strDataImport&gt;&gt; loadstrDataAsync(string FileName)
      {
          var engine_Data = new FileHelperAsyncEngine&lt;strData&gt;();
          engine_Data.BeforeReadRecord += BeforeEventAsync;
          engine_Data.AfterReadRecord += AfterEventAsync;
  
          engine_Data.Progress += ReadProgress;
  
          List&lt;strData&gt; list = new List&lt;strData&gt;();
          List&lt;List&lt;Structs.strDataImport&gt;&gt; list2D = new List&lt;List&lt;Structs.strDataImport&gt;&gt;();
  
          using (engine_Data.BeginReadFile(FileName))
          {
              var prevRowNo = 0;
              var j = 0;
              strCnt = 0;
              foreach (strData filteredData in engine_Data)
              {
                  if (prevRowNo &gt; filteredData.RowNo)
                  {
                      list2D.Add(copyList(list));
                      list.Clear();
                  }
                  prevRowNo = filteredData.RowNo;
                  list.Add(filteredData);
              }
              list2D.Add(copyList(list));
  
          }
  
          return list2D;
  
      }
  
      private Type strIDSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
          if (recordLine.Contains("** #_DATA .STATUS .STRID **"))
              return typeof(strID);
          else
          {
              return null;
          }
  
      }
  
      private Type InfoSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
          if (recordLine.Contains("** #_FILE **"))
              return typeof(strInfo);
          else
          {
              return null;
          }
  
      }
  
      private Type strDataSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_DATA **"))
              return typeof(strData);
          else
          {
              return null;
          }
  
      }
  
      private Type strSetupSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_SETUP **"))
              return typeof(strSetup);
          else
          {
              return null;
          }
  
      }
  
      private Type strValidDataSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_VALID_DATA **"))
              return typeof(strValidData);
          else
          {
              return null;
          }
  
      }
  
      private Type StartNumSelector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_START_NUMBER **"))
              return typeof(strStartNum);
          else
          {
              return null;
          }
  
      }
  
      private Type str1Selector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_1 **"))
              return typeof(str1);
          else
          {
              return null;
          }
  
      }
  
      private Type str4Selector(MultiRecordEngine engine, string recordLine)
      {
          if (recordLine.Length == 0)
              return null;
  
          if (recordLine.Contains("** #_4 **"))
              return typeof(str4);
          else
          {
              return null;
          }
  
      }
  
      private void BeforeEventAsync(EngineBase engine, BeforeReadEventArgs&lt;strData&gt; e)
      {
          if (e.RecordLine != "")
          {
              if (Char.IsDigit(e.RecordLine, 0))
              {
  
              }
              else
              {
                  e.SkipThisRecord = true;
              }
          }
  
          if (e.RecordLine.Contains("** #_VALID_DATA **;"))
          {
              e.SkipThisRecord = true;
          }
  
  
  
  
      }
  
      private void AfterEventAsync(EngineBase engine, AfterReadEventArgs&lt;strData&gt; e)
      {
  
          if (e.RecordLine.Contains("** #_VALID_DATA **;"))
          {
              e.SkipThisRecord = true;
          }
  
  
      }
  
      private void ReadProgress(object sender, ProgressEventArgs e)
      {
          ShowWaitForm("Opening file." + "\n" + "\n" + "Please wait...", "Open File");
          _waitForm.progressBar1.Value = Convert.ToInt16(e.Percent);
      }
  
      public void ShowWaitForm(string message, string caption)
      {
          if (_waitForm != null &amp;&amp; !_waitForm.IsDisposed)
          {
              return;
          }
  
          _waitForm = new readCSVprogressForm();
          _waitForm.ShowMessage(message); 
          _waitForm.Text = caption;
          _waitForm.TopMost = true;
          _waitForm.Show();
          _waitForm.Refresh();
  
  
          System.Threading.Thread.Sleep(700);
          Application.Idle += OnLoaded;
  
      }
  
      private void OnLoaded(object sender, EventArgs e)
      {
          Application.Idle -= OnLoaded;
          _waitForm.Close();
      }
  
  
  }
  </code></pre>
  
  <p>}</p>