How to append existing excel file using C#

As already commented… I can confirm from a few tests that …

FileMode.Append

Will not work as you are intending. This seems somewhat obvious since a workbook can have multiple worksheets and what you describe is appending the data to an existing worksheet… The FileStream will not know how to do this.

Therefore, as already described, you need to open the file, make the changes (append the rows) and then save the file and close it. In my tests this worked using most of your code with some minor changes. In your current code, it is always creating a “new” Excel workbook and worksheet. So if you want to “append” something to a worksheet, then that “implies” that the workbook and worksheet may already exists. So, if the workbook already exists, then we want to open it and not create a new one.

Therefore, I suggest a small method that takes a string file path and file name and returns a workbook. If the workbook exists, then we simply return the workbook. If the workbook does not exist, then we return a “new” workbook. If the path is bad or any other failure… we will return a null value. Something like…

private XSSFWorkbook GetExcelWorkbook(string filePath) {
  if (!File.Exists(filePath)) {
    return new XSSFWorkbook();
  }
  try {
    using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
      return new XSSFWorkbook(fs);
    }
  }
  catch (Exception ex) {
    Debug.WriteLine("Excel Error getting workbook: " + ex.Message);
    return null;
  }
}

This should help getting the workbook. Next, It appears the code is looking for a “specific” worksheet. Similar to the code above a simple method that takes a workbook and a worksheet name and returns a worksheet with the given name may come in handy. Again, if the worksheet already exists, then we simply return that worksheet. If the worksheet does not exist, then we will create a new worksheet with the given name. In addition, we will go ahead and add the headers row if the worksheet is new. This is also in another method so that you could also add the header row each time new data is appended. However in this example, the header is added only when a new worksheet is created and assumes the header row already exist in existing files.

This method may look something like…

private ISheet GetWorksheet(XSSFWorkbook wb, string targetSheetName) {
  try {
    for (int i = 0; i < wb.NumberOfSheets; i++) {
      if (wb.GetSheetAt(i).SheetName.Equals(targetSheetName)) {
        return wb.GetSheetAt(i);
      }
    }
    ISheet ws = wb.CreateSheet(targetSheetName);
    AddHeaders(wb, ws);
    return ws;
  }
  catch (Exception e) {
    Debug.WriteLine("Excel Error getting worksheet: " + e.Message);
    return null;
  }
}

A walkthrough of the code above is straight forward… Loop through the given workbooks worksheets to look for the target worksheet name. If the worksheet is found it is returned. If the worksheet is not found, then a new worksheet is created with the target name, add the headers to the new worksheet then return the new worksheet. If some error arises a null value is returned.

Next is the method that adds the headers to the worksheet and is taken almost directly from your code.

private void AddHeaders(XSSFWorkbook wb, ISheet sheet) {
  IRow headerrow = sheet.CreateRow(0);
  headerrow.HeightInPoints = 20;
  headerrow.CreateCell(0).SetCellValue("System_name");
  headerrow.CreateCell(1).SetCellValue("Fixture_name");
  headerrow.CreateCell(2).SetCellValue("build_ID");
  headerrow.CreateCell(3).SetCellValue("start_time");
  headerrow.CreateCell(4).SetCellValue("end_time");
  headerrow.CreateCell(5).SetCellValue("serial_number");
  headerrow.CreateCell(6).SetCellValue("Status");
  headerrow.CreateCell(7).SetCellValue("Symptom_label");
  headerrow.CreateCell(8).SetCellValue("Repair");
  headerrow.CreateCell(9).SetCellValue("Measurement");
  headerrow.CreateCell(10).SetCellValue("Board_slot");
  headerrow.CreateCell(11).SetCellValue("Error");
  headerrow.CreateCell(12).SetCellValue("Version");
  ICellStyle headerStyle = wb.CreateCellStyle();
  IFont headerfont = wb.CreateFont();
  headerStyle.Alignment = HorizontalAlignment.Center;
  headerStyle.VerticalAlignment = VerticalAlignment.Center;
  headerfont.FontName = "Segoe UI";
  headerfont.FontHeightInPoints = 12;
  headerfont.Boldweight = (short)FontBoldWeight.Bold;
  headerStyle.SetFont(headerfont);
  for (int i = 0; i < 13; i++) {
    headerrow.GetCell(i).CellStyle = headerStyle;
  }
}

These methods should simplify “appending” data to an existing worksheet or creating a new worksheet. So, using the above methods, the code below works as described here… This code is added to a button clicks event. Initially, some test data is created for the DataTable dt that will be appended to the worksheet. Next, we check if the given folder path exists and if not, then create it.

Next we use our methods above to get the workbook and also the worksheet. The worksheet name is as you have in the current code and is coming from a TextBox ...tbx_Build on the form.

Next, instead of setting rowIndex to 1, we set it to the last row of existing data in the worksheet so we can “append” the data. Specifically the line…

int rowIndex = ws.LastRowNum + 1;

Next a cell style is created and a loop through the DataTables dt rows where each cell is added to the worksheet. Note I removed the unnecessary “Convert” code and used the cells ToString() method. And finally a style is added to some cells for some reason.

And lastly, the FilesStream is created to save the file and possibly overwrite it when it’s not new.

You may note, that the workbook wb is closed in the finally portion of the try/catch/finally statement and the reason for this is that if the code fails sometime after the workbook is open, then it may not get closed. This ensures that the workbook is properly closed.

private void button1_Click(object sender, EventArgs e) {
  string workbookName = "__NewBook_1.xlsx";
  string saveFilePath = @"D:\Test\Excel_Test";
  DataTable dt = GetTable();
  FillTable(dt);
  XSSFWorkbook wb = null;
  try {
    if (!Directory.Exists(saveFilePath)) {
      Directory.CreateDirectory(saveFilePath);
    }
    wb = GetExcelWorkbook(saveFilePath + @"\" + workbookName);
    if (wb != null) {
      ISheet ws = GetWorksheet(wb, tbx_Build.Text);
      if (ws != null) {
        int rowIndex = ws.LastRowNum + 1;
        ICellStyle cs = wb.CreateCellStyle();
        cs.WrapText = true;
        cs.VerticalAlignment = VerticalAlignment.Top;
        for (int i = 0; i < dt.Rows.Count; i++) {
          IRow row = ws.CreateRow(rowIndex);
          row.HeightInPoints = 18;
          row.CreateCell(0).SetCellValue(dt.Rows[i]["System_name"].ToString());
          row.CreateCell(1).SetCellValue(dt.Rows[i]["Fixture_name"].ToString());
          row.CreateCell(2).SetCellValue(dt.Rows[i]["build_ID"].ToString());
          row.CreateCell(3).SetCellValue(dt.Rows[i]["start_time"].ToString());
          row.CreateCell(4).SetCellValue(dt.Rows[i]["end_time"].ToString());
          row.CreateCell(5).SetCellValue(dt.Rows[i]["serial_number"].ToString());
          row.CreateCell(6).SetCellValue(dt.Rows[i]["Status"].ToString());
          row.CreateCell(7).SetCellValue(dt.Rows[i]["Symptom_label"].ToString());
          row.CreateCell(8).SetCellValue(dt.Rows[i]["Repair"].ToString());
          row.CreateCell(9).SetCellValue(dt.Rows[i]["Measurement"].ToString());
          row.CreateCell(10).SetCellValue(dt.Rows[i]["Board_slot"].ToString());
          row.CreateCell(11).SetCellValue(dt.Rows[i]["Error"].ToString());
          row.CreateCell(12).SetCellValue(dt.Rows[i]["Version"].ToString());
          if (dt.Rows[i]["Error"].ToString().Contains("\n")) {
            row.GetCell(12).CellStyle = cs;
            row.HeightInPoints = 45;
          }
          else if (dt.Rows[i]["Repair"].ToString().Contains("\n")) {
            row.GetCell(12).CellStyle = cs;
            row.HeightInPoints = 45;
          }
          ws.AutoSizeColumn(i);
          rowIndex++;
        }
        using (FileStream fs = new FileStream(saveFilePath + @"\" + workbookName, FileMode.Create, FileAccess.Write)) {
          wb.Write(fs, true);
        }
      }
    }
  }
  catch (Exception ex) {
    Debug.WriteLine("Excel Error: " + ex.Message);
  }
  finally {
    if (wb != null) {
      wb.Close();
    }
  }
}

And finally the code that creates some test data to test the above methods and complete the example.

using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using HorizontalAlignment = NPOI.SS.UserModel.HorizontalAlignment;


private DataTable GetTable() {
  DataTable dt = new DataTable();
  dt.Columns.Add("System_name");
  dt.Columns.Add("Fixture_name");
  dt.Columns.Add("build_ID");
  dt.Columns.Add("start_time");
  dt.Columns.Add("end_time");
  dt.Columns.Add("serial_number");
  dt.Columns.Add("Status");
  dt.Columns.Add("Symptom_label");
  dt.Columns.Add("Repair");
  dt.Columns.Add("Measurement");
  dt.Columns.Add("Board_slot");
  dt.Columns.Add("Error");
  dt.Columns.Add("Version");
  return dt;
}

private void FillTable(DataTable dt) {
  for (int i = 0; i < 20; i++) {
    dt.Rows.Add("C0R" + (i + 1), "C1R" + (i + 1), "C2R" + (i + 1), "C3R" + (i + 1), "C4R" + (i + 1),
                "C5R" + (i + 1), "C6R" + (i + 1), "C7R" + (i + 1), "C8R" + (i + 1), "C9R" + (i + 1),
                "C10R" + (i + 1), "C11R" + (i + 1), "C12R" + (i + 1));
  }
}

I hope this makes sense. I tested this numerous times and it appears to work as expected, however there may still be some necessary exception checking that was not added for brevity. If something is not correct please let me know and I will correct it if possible.