C#操作Excel

原創 CQBSBJIANXY 2020-02-22 01:49 
using System;
using System.IO;
using System.Text;
using System.Data;
using System.Reflection;
using System.Diagnostics;
using System.Collections;

//using cfg = System.Configuration;

namespace GDBI.Common
{
 /// <summary>
 /// 說    明：Excel輸出打印模塊
 ///     暫時不提供操作Excel對象樣式方法，樣式可以在Excel模板中設置好
 /// </summary>
 public class ExcelHelper
 {
  #region 成員變量
  private string templetFile = null;
  private string outputFile = null;
  private object missing = Missing.Value;
  private DateTime beforeTime;   //Excel啓動之前時間
  private DateTime afterTime;    //Excel啓動之後時間
  Excel.Application app;
  Excel.Workbook workBook;
  Excel.Worksheet workSheet;
  Excel.Range range;
  Excel.Range range1;
  Excel.Range range2;
  Excel.TextBox textBox;
  private int sheetCount = 1;   //WorkSheet數量
  private string sheetPrefixName = "頁"; 
  #endregion

  #region 公共屬性
  /// <summary>
  /// WorkSheet前綴名，比如：前綴名爲“頁”，那麼WorkSheet名稱依次爲“頁-1，頁-2...”
  /// </summary>
  public string SheetPrefixName
  {
   set { this.sheetPrefixName = value; }
  }

  /// <summary>
  /// WorkSheet數量
  /// </summary>
  public int WorkSheetCount
  {
   get { return workBook.Sheets.Count; }
  }

  /// <summary>
  /// Excel模板文件路徑
  /// </summary>
  public string TempletFilePath
  {
   set { this.templetFile = value; }
  }

  /// <summary>
  /// 輸出Excel文件路徑
  /// </summary>
  public string OutputFilePath
  {
   set { this.outputFile = value; }
  }
  #endregion

  #region 公共方法

  #region ExcelHelper
  /// <summary>
  /// 構造函數，將一個已有Excel工作簿作爲模板，並指定輸出路徑
  /// </summary>
  /// <param name="templetFilePath">Excel模板文件路徑</param>
  /// <param name="outputFilePath">輸出Excel文件路徑</param>
  public ExcelHelper(string templetFilePath,string outputFilePath)
  {
   if(templetFilePath == null)
    throw new Exception("Excel模板文件路徑不能爲空！");

   if(outputFilePath == null)
    throw new Exception("輸出Excel文件路徑不能爲空！");

   if(!File.Exists(templetFilePath))
    throw new Exception("指定路徑的Excel模板文件不存在！");

   this.templetFile = templetFilePath;
   this.outputFile = outputFilePath;

   //創建一個Application對象並使其可見
   beforeTime = DateTime.Now;
   app = new Excel.ApplicationClass();
   app.Visible = true;
   afterTime = DateTime.Now;

   //打開模板文件，得到WorkBook對象
   workBook = app.Workbooks.Open(templetFile,missing,missing,missing,missing,missing,
    missing,missing,missing,missing,missing,missing,missing);

   //得到WorkSheet對象
   workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(1);

  }

  /// <summary>
  /// 構造函數，打開一個已有的工作簿
  /// </summary>
  /// <param name="fileName">Excel文件名</param>
  public ExcelHelper(string fileName)
  {
   if(!File.Exists(fileName))
    throw new Exception("指定路徑的Excel文件不存在！");

   //創建一個Application對象並使其可見
   beforeTime = DateTime.Now;
   app = new Excel.ApplicationClass();
   app.Visible = true;
   afterTime = DateTime.Now;

   //打開一個WorkBook
   workBook = app.Workbooks.Open(fileName,
    Type.Missing, Type.Missing, Type.Missing, Type.Missing,
    Type.Missing, Type.Missing, Type.Missing, Type.Missing,
    Type.Missing, Type.Missing, Type.Missing, Type.Missing);

   //得到WorkSheet對象
   workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(1);

  }

  /// <summary>
  /// 構造函數，新建一個工作簿
  /// </summary>
  public ExcelHelper()
  {
   //創建一個Application對象並使其可見
   beforeTime = DateTime.Now;
   app = new Excel.ApplicationClass();
   app.Visible = true;
   afterTime = DateTime.Now;

   //新建一個WorkBook
   workBook = app.Workbooks.Add(Type.Missing);

   //得到WorkSheet對象
   workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(1);

  }
  #endregion

  #region Data Export Methods

  /// <summary>
  /// 將DataTable數據寫入Excel文件（自動分頁）
  /// </summary>
  /// <param name="dt">DataTable</param>
  /// <param name="rows">每個WorkSheet寫入多少行數據</param>
  /// <param name="top">表格數據起始行索引</param>
  /// <param name="left">表格數據起始列索引</param>
  public void DataTableToExcel(DataTable dt,int rows,int top,int left)
  {
   int rowCount = dt.Rows.Count;  //DataTable行數
   int colCount = dt.Columns.Count; //DataTable列數
   sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet個數
//   StringBuilder sb;
    
   //複製sheetCount-1個WorkSheet對象
   for(int i=1;i<sheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Copy(missing,workBook.Worksheets[i]);
   }
  
   for(int i=1;i<=sheetCount;i++)
   {
    int startRow = (i - 1) * rows;  //記錄起始行索引
    int endRow = i * rows;   //記錄結束行索引
  
    //若是最後一個WorkSheet，那麼記錄結束行索引爲源DataTable行數
    if(i == sheetCount)
     endRow = rowCount;
  
    //獲取要寫入數據的WorkSheet對象，並重命名
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Name = sheetPrefixName + "-" + i.ToString();
  
    //將dt中的數據寫入WorkSheet
//    for(int j=0;j<endRow-startRow;j++)
//    {
//     for(int k=0;k<colCount;k++)
//     {
//      workSheet.Cells[top + j,left + k] = dt.Rows[startRow + j][k].ToString();
//     }
//    }

    //利用二維數組批量寫入
    int row = endRow-startRow;
    string[,] ss = new string[row,colCount];

    for(int j=0;j<row;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      ss[j,k] = dt.Rows[startRow + j][k].ToString();
     }
    }

    range = (Excel.Range)workSheet.Cells[top,left];
    range = range.get_Resize(row,colCount);
    range.Value = ss;

    #region 利用Windwo粘貼板批量拷貝數據（在Web下面行不通）
    /*sb = new StringBuilder();

    for(int j=0;j<endRow-startRow;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      sb.Append( dt.Rows[startRow + j][k].ToString() );
      sb.Append("/t");
     }

     sb.Append("/n");
    }

    System.Windows.Forms.Clipboard.SetDataObject(sb.ToString());

    range = (Excel.Range)workSheet.Cells[top,left];
    workSheet.Paste(range,false);*/
    #endregion
      
   }
  }

  /// <summary>
  /// 將DataTable數據寫入Excel文件（不分頁）
  /// </summary>
  /// <param name="dt">DataTable</param>
  /// <param name="top">表格數據起始行索引</param>
  /// <param name="left">表格數據起始列索引</param>
  public void DataTableToExcel(DataTable dt,int top,int left)
  {
   int rowCount = dt.Rows.Count;  //DataTable行數
   int colCount = dt.Columns.Count; //DataTable列數

   //利用二維數組批量寫入
   string[,] arr = new string[rowCount,colCount];

   for(int j=0;j<rowCount;j++)
   {
    for(int k=0;k<colCount;k++)
    {
     arr[j,k] = dt.Rows[j][k].ToString();
    }
   }

   range = (Excel.Range)workSheet.Cells[top,left];
   range = range.get_Resize(rowCount,colCount);
   range.Value = arr;
  }

  /// <summary>
  /// 將DataTable數據寫入Excel文件（自動分頁，並指定要合併的列索引）
  /// </summary>
  /// <param name="dt">DataTable</param>
  /// <param name="rows">每個WorkSheet寫入多少行數據</param>
  /// <param name="top">表格數據起始行索引</param>
  /// <param name="left">表格數據起始列索引</param>
  /// <param name="mergeColumnIndex">DataTable中要合併相同行的列索引，從0開始</param>
  public void DataTableToExcel(DataTable dt,int rows,int top,int left,int mergeColumnIndex)
  {
   int rowCount = dt.Rows.Count;  //源DataTable行數
   int colCount = dt.Columns.Count; //源DataTable列數
   sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet個數
//   StringBuilder sb;
    
   //複製sheetCount-1個WorkSheet對象
   for(int i=1;i<sheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Copy(missing,workBook.Worksheets[i]);
   }
  
   for(int i=1;i<=sheetCount;i++)
   {
    int startRow = (i - 1) * rows;  //記錄起始行索引
    int endRow = i * rows;   //記錄結束行索引
  
    //若是最後一個WorkSheet，那麼記錄結束行索引爲源DataTable行數
    if(i == sheetCount)
     endRow = rowCount;
  
    //獲取要寫入數據的WorkSheet對象，並重命名
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Name = sheetPrefixName + "-" + i.ToString();
  
    //將dt中的數據寫入WorkSheet
//    for(int j=0;j<endRow-startRow;j++)
//    {
//     for(int k=0;k<colCount;k++)
//     {
//      workSheet.Cells[top + j,left + k] = dt.Rows[startRow + j][k].ToString();
//     }
//    }

    //利用二維數組批量寫入
    int row = endRow-startRow;
    string[,] ss = new string[row,colCount];

    for(int j=0;j<row;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      ss[j,k] = dt.Rows[startRow + j][k].ToString();
     }
    }

    range = (Excel.Range)workSheet.Cells[top,left];
    range = range.get_Resize(row,colCount);
    range.Value = ss;

    //合併相同行
    this.MergeRows(workSheet,left+mergeColumnIndex,top,rows);
      
   }
  }

  /// <summary>
  /// 將二維數組數據寫入Excel文件（自動分頁）
  /// </summary>
  /// <param name="arr">二維數組</param>
  /// <param name="rows">每個WorkSheet寫入多少行數據</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  public void ArrayToExcel(string[,] arr,int rows,int top,int left)
  {
   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）
   sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet個數

   //複製sheetCount-1個WorkSheet對象
   for(int i=1;i<sheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Copy(missing,workBook.Worksheets[i]);
   }

   //將二維數組數據寫入Excel
   for(int i=sheetCount;i>=1;i--)
   {
    int startRow = (i - 1) * rows;  //記錄起始行索引
    int endRow = i * rows;   //記錄結束行索引

    //若是最後一個WorkSheet，那麼記錄結束行索引爲源DataTable行數
    if(i == sheetCount)
     endRow = rowCount;

    //獲取要寫入數據的WorkSheet對象，並重命名
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Name = sheetPrefixName + "-" + i.ToString();

    //將二維數組中的數據寫入WorkSheet
//    for(int j=0;j<endRow-startRow;j++)
//    {
//     for(int k=0;k<colCount;k++)
//     {
//      workSheet.Cells[top + j,left + k] = arr[startRow + j,k];
//     }
//    }

    //利用二維數組批量寫入
    int row = endRow-startRow;
    string[,] ss = new string[row,colCount];

    for(int j=0;j<row;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      ss[j,k] = arr[startRow + j,k];
     }
    }

    range = (Excel.Range)workSheet.Cells[top,left];
    range = range.get_Resize(row,colCount);
    range.Value = ss;
   }
   
  }//end ArrayToExcel

  /// <summary>
  /// 將二維數組數據寫入Excel文件（不分頁）
  /// </summary>
  /// <param name="arr">二維數組</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  public void ArrayToExcel(string[,] arr,int top,int left)
  {
   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）

   range = (Excel.Range)workSheet.Cells[top,left];
   range = range.get_Resize(rowCount,colCount);
   range.FormulaArray = arr;
   
  }//end ArrayToExcel

  /// <summary>
  /// 將二維數組數據寫入Excel文件（不分頁）
  /// </summary>
  /// <param name="arr">二維數組</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  /// <param name="isFormula">填充的數據是否需要計算</param>
  public void ArrayToExcel(string[,] arr,int top,int left,bool isFormula)
  {
   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）

   range = (Excel.Range)workSheet.Cells[top,left];
   range = range.get_Resize(rowCount,colCount);

   //注意：使用range.FormulaArray寫合併的單元格會出問題
   if(isFormula)
    range.FormulaArray = arr;
   else
    range.Value = arr;
   
  }//end ArrayToExcel

  /// <summary>
  /// 將二維數組數據寫入Excel文件（不分頁），合併指定列的相同行
  /// </summary>
  /// <param name="arr">二維數組</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  /// <param name="isFormula">填充的數據是否需要計算</param>
  /// <param name="mergeColumnIndex">需要合併行的列索引</param>
  public void ArrayToExcel(string[,] arr,int top,int left,bool isFormula,int mergeColumnIndex)
  {
   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）

   range = (Excel.Range)workSheet.Cells[top,left];
   range = range.get_Resize(rowCount,colCount);

   //注意：使用range.FormulaArray寫合併的單元格會出問題
   if(isFormula)
    range.FormulaArray = arr;
   else
    range.Value = arr;

   this.MergeRows(workSheet,mergeColumnIndex,top,rowCount);
   
  }//end ArrayToExcel

  /// <summary>
  /// 將二維數組數據寫入Excel文件（不分頁）
  /// </summary>
  /// <param name="sheetIndex">工作表索引</param>
  /// <param name="arr">二維數組</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  public void ArrayToExcel(int sheetIndex,string[,] arr,int top,int left)
  {
   if(sheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   // 改變當前工作表
   this.workSheet = (Excel.Worksheet)this.workBook.Sheets.get_Item(sheetIndex);

   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）

   range = (Excel.Range)workSheet.Cells[top,left];
   range = range.get_Resize(rowCount,colCount);

   range.Value2 = arr;
   
  }//end ArrayToExcel

  /// <summary>
  /// 將二維數組數據寫入Excel文件（自動分頁，並指定要合併的列索引）
  /// </summary>
  /// <param name="arr">二維數組</param>
  /// <param name="rows">每個WorkSheet寫入多少行數據</param>
  /// <param name="top">行索引</param>
  /// <param name="left">列索引</param>
  /// <param name="mergeColumnIndex">數組的二維索引，相當於DataTable的列索引，索引從0開始</param>
  public void ArrayToExcel(string[,] arr,int rows,int top,int left,int mergeColumnIndex)
  {
   int rowCount = arr.GetLength(0);  //二維數組行數（一維長度）
   int colCount = arr.GetLength(1); //二維數據列數（二維長度）
   sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet個數

   //複製sheetCount-1個WorkSheet對象
   for(int i=1;i<sheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Copy(missing,workBook.Worksheets[i]);
   }

   //將二維數組數據寫入Excel
   for(int i=sheetCount;i>=1;i--)
   {
    int startRow = (i - 1) * rows;  //記錄起始行索引
    int endRow = i * rows;   //記錄結束行索引

    //若是最後一個WorkSheet，那麼記錄結束行索引爲源DataTable行數
    if(i == sheetCount)
     endRow = rowCount;

    //獲取要寫入數據的WorkSheet對象，並重命名
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
    workSheet.Name = sheetPrefixName + "-" + i.ToString();

    //將二維數組中的數據寫入WorkSheet
    for(int j=0;j<endRow-startRow;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      workSheet.Cells[top + j,left + k] = arr[startRow + j,k];
     }
    }

    //利用二維數組批量寫入
    int row = endRow-startRow;
    string[,] ss = new string[row,colCount];

    for(int j=0;j<row;j++)
    {
     for(int k=0;k<colCount;k++)
     {
      ss[j,k] = arr[startRow + j,k];
     }
    }

    range = (Excel.Range)workSheet.Cells[top,left];
    range = range.get_Resize(row,colCount);
    range.Value = ss;

    //合併相同行
    this.MergeRows(workSheet,left+mergeColumnIndex,top,rows);
   }
   
  }//end ArrayToExcel
  #endregion

  #region WorkSheet Methods

  /// <summary>
  /// 改變當前工作表
  /// </summary>
  /// <param name="sheetIndex">工作表索引</param>
  public void ChangeCurrentWorkSheet(int sheetIndex)
  {
   //若指定工作表索引超出範圍，則不改變當前工作表
   if(sheetIndex < 1)
    return;

   if(sheetIndex > this.WorkSheetCount)
    return;

   this.workSheet = (Excel.Worksheet)this.workBook.Sheets.get_Item(sheetIndex);
  }
  /// <summary>
  /// 隱藏指定名稱的工作表
  /// </summary>
  /// <param name="sheetName">工作表名稱</param>
  public void HiddenWorkSheet(string sheetName)
  {
   try
   {
    Excel.Worksheet sheet = null;

    for(int i=1;i<=this.WorkSheetCount;i++)
    {
     workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);
     
     if(workSheet.Name == sheetName)
      sheet = workSheet;
    }

    if(sheet != null)
     sheet.Visible = Excel.XlSheetVisibility.xlSheetHidden;
    else
    {
     this.KillExcelProcess();
     throw new Exception("名稱爲/"" + sheetName + "/"的工作表不存在");
    }
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  /// <summary>
  /// 隱藏指定索引的工作表
  /// </summary>
  /// <param name="sheetIndex"></param>
  public void HiddenWorkSheet(int sheetIndex)
  {
   if(sheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   try
   {
    Excel.Worksheet sheet = null;
    sheet = (Excel.Worksheet)workBook.Sheets.get_Item(sheetIndex);

    sheet.Visible = Excel.XlSheetVisibility.xlSheetHidden;
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  /// <summary>
  /// 在指定名稱的工作表後面拷貝指定個數的該工作表的副本，並重命名
  /// </summary>
  /// <param name="sheetName">工作表名稱</param>
  /// <param name="sheetCount">工作表個數</param>
  public void CopyWorkSheets(string sheetName,int sheetCount)
  {
   try
   {
    Excel.Worksheet sheet = null;
    int sheetIndex = 0;

    for(int i=1;i<=this.WorkSheetCount;i++)
    {
     workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);
     
     if(workSheet.Name == sheetName)
     {
      sheet = workSheet;
      sheetIndex = workSheet.Index;
     }
    }

    if(sheet != null)
    {
     for(int i=sheetCount;i>=1;i--)
     {
      sheet.Copy(this.missing,sheet);
     }

     //重命名
     for(int i=sheetIndex;i<=sheetIndex+sheetCount;i++)
     {
      workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);
      workSheet.Name = sheetName + "-" + Convert.ToString(i - sheetIndex + 1);
     }
    }
    else
    {
     this.KillExcelProcess();
     throw new Exception("名稱爲/"" + sheetName + "/"的工作表不存在");
    }
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  /// <summary>
  /// 將一個工作表拷貝到另一個工作表後面，並重命名
  /// </summary>
  /// <param name="srcSheetIndex">拷貝源工作表索引</param>
  /// <param name="aimSheetIndex">參照位置工作表索引，新工作表拷貝在該工作表後面</param>
  /// <param name="newSheetName"></param>
  public void CopyWorkSheet(int srcSheetIndex,int aimSheetIndex,string newSheetName)
  {
   if(srcSheetIndex > this.WorkSheetCount || aimSheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   try
   {
    Excel.Worksheet srcSheet = (Excel.Worksheet)workBook.Sheets.get_Item(srcSheetIndex);
    Excel.Worksheet aimSheet = (Excel.Worksheet)workBook.Sheets.get_Item(aimSheetIndex);
    
    srcSheet.Copy(this.missing,aimSheet);
     
    //重命名
    workSheet = (Excel.Worksheet)aimSheet.Next;  //獲取新拷貝的工作表
    workSheet.Name = newSheetName;
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  /// <summary>
  /// 根據名稱刪除工作表
  /// </summary>
  /// <param name="sheetName"></param>
  public void DeleteWorkSheet(string sheetName)
  {
   try
   {
    Excel.Worksheet sheet = null;

    //找到名稱位sheetName的工作表
    for(int i=1;i<=this.WorkSheetCount;i++)
    {
     workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);
     
     if(workSheet.Name == sheetName)
     {
      sheet = workSheet;
     }
    }

    if(sheet != null)
    {
     sheet.Delete();
    }
    else
    {
     this.KillExcelProcess();
     throw new Exception("名稱爲/"" + sheetName + "/"的工作表不存在");
    }
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  /// <summary>
  /// 根據索引刪除工作表
  /// </summary>
  /// <param name="sheetIndex"></param>
  public void DeleteWorkSheet(int sheetIndex)
  {
   if(sheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   try
   {
    Excel.Worksheet sheet = null;
    sheet = (Excel.Worksheet)workBook.Sheets.get_Item(sheetIndex);

    sheet.Delete();
   }
   catch(Exception e)
   {
    this.KillExcelProcess();
    throw e;
   }
  }

  #endregion

  #region TextBox Methods
  /// <summary>
  /// 向指定文本框寫入數據，對每個WorkSheet操作
  /// </summary>
  /// <param name="textboxName">文本框名稱</param>
  /// <param name="text">要寫入的文本</param>
  public void SetTextBox(string textboxName,string text)
  {
   for(int i=1;i<=this.WorkSheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);

    try
    {
     textBox = (Excel.TextBox)workSheet.TextBoxes(textboxName);
     textBox.Text = text;
    }
    catch
    {
     this.KillExcelProcess();
     throw new Exception("不存在ID爲/"" + textboxName + "/"的文本框！");
    }
   }
  }

  /// <summary>
  /// 向指定文本框寫入數據，對指定WorkSheet操作
  /// </summary>
  /// <param name="sheetIndex">工作表索引</param>
  /// <param name="textboxName">文本框名稱</param>
  /// <param name="text">要寫入的文本</param>
  public void SetTextBox(int sheetIndex,string textboxName,string text)
  {
   workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);

   try
   {
    textBox = (Excel.TextBox)workSheet.TextBoxes(textboxName);
    textBox.Text = text;
   }
   catch
   {
    this.KillExcelProcess();
    throw new Exception("不存在ID爲/"" + textboxName + "/"的文本框！");
   }
  }

  /// <summary>
  /// 向文本框寫入數據，對每個WorkSheet操作
  /// </summary>
  /// <param name="ht">Hashtable的鍵值對保存文本框的ID和數據</param>
  public void SetTextBoxes(Hashtable ht)
  {
   if(ht.Count == 0) return;

   for(int i=1;i<=this.WorkSheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);

    foreach(DictionaryEntry dic in ht)
    {
     try
     {
      textBox = (Excel.TextBox)workSheet.TextBoxes(dic.Key);
      textBox.Text = dic.Value.ToString();
     }
     catch
     {
      this.KillExcelProcess();
      throw new Exception("不存在ID爲/"" + dic.Key.ToString() + "/"的文本框！");
     }
    }
   }
  }

  /// <summary>
  /// 向文本框寫入數據，對指定WorkSheet操作
  /// </summary>
  /// <param name="ht">Hashtable的鍵值對保存文本框的ID和數據</param>
  public void SetTextBoxes(int sheetIndex,Hashtable ht)
  {
   if(ht.Count == 0) return;

   if(sheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);

   foreach(DictionaryEntry dic in ht)
   {
    try
    {
     textBox = (Excel.TextBox)workSheet.TextBoxes(dic.Key);
     textBox.Text = dic.Value.ToString();
    }
    catch
    {
     this.KillExcelProcess();
     throw new Exception("不存在ID爲/"" + dic.Key.ToString() + "/"的文本框！");
    }
   }
  }
  #endregion

  #region Cell Methods
  /// <summary>
  /// 向單元格寫入數據，對當前WorkSheet操作
  /// </summary>
  /// <param name="rowIndex">行索引</param>
  /// <param name="columnIndex">列索引</param>
  /// <param name="text">要寫入的文本值</param>
  public void SetCells(int rowIndex,int columnIndex,string text)
  {
   try
   {
    workSheet.Cells[rowIndex,columnIndex] = text;
   }
   catch
   {
    this.KillExcelProcess();
    throw new Exception("向單元格[" + rowIndex + "," + columnIndex + "]寫數據出錯！");
   }
  }

  /// <summary>
  /// 向單元格寫入數據，對指定WorkSheet操作
  /// </summary>
  /// <param name="sheetIndex">工作表索引</param>
  /// <param name="rowIndex">行索引</param>
  /// <param name="columnIndex">列索引</param>
  /// <param name="text">要寫入的文本值</param>
  public void SetCells(int sheetIndex,int rowIndex,int columnIndex,string text)
  {
   try
   {
    this.ChangeCurrentWorkSheet(sheetIndex); //改變當前工作表爲指定工作表
    workSheet.Cells[rowIndex,columnIndex] = text;
   }
   catch
   {
    this.KillExcelProcess();
    throw new Exception("向單元格[" + rowIndex + "," + columnIndex + "]寫數據出錯！");
   }
  }

  /// <summary>
  /// 向單元格寫入數據，對每個WorkSheet操作
  /// </summary>
  /// <param name="ht">Hashtable的鍵值對保存單元格的位置索引（行索引和列索引用“,”隔開）和數據</param>
  public void SetCells(Hashtable ht)
  {
   int rowIndex;
   int columnIndex;
   string position;

   if(ht.Count == 0) return;

   for(int i=1;i<=this.WorkSheetCount;i++)
   {
    workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);

    foreach(DictionaryEntry dic in ht)
    {
     try
     {
      position = dic.Key.ToString();
      rowIndex = Convert.ToInt32(position.Split(',')[0]);
      columnIndex = Convert.ToInt32(position.Split(',')[1]);
      
      workSheet.Cells[rowIndex,columnIndex] = dic.Value;
     }
     catch
     {
      this.KillExcelProcess();
      throw new Exception("向單元格[" + dic.Key + "]寫數據出錯！");
     }
    }
   }
  }

  /// <summary>
  /// 向單元格寫入數據，對指定WorkSheet操作
  /// </summary>
  /// <param name="ht">Hashtable的鍵值對保存單元格的位置索引（行索引和列索引用“,”隔開）和數據</param>
  public void SetCells(int sheetIndex,Hashtable ht)
  {
   int rowIndex;
   int columnIndex;
   string position;

   if(sheetIndex > this.WorkSheetCount)
   {
    this.KillExcelProcess();
    throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
   }

   if(ht.Count == 0) return;

   workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);

   foreach(DictionaryEntry dic in ht)
   {
    try
    {
     position = dic.Key.ToString();
     rowIndex = Convert.ToInt32(position.Split(',')[0]);
     columnIndex = Convert.ToInt32(position.Split(',')[1]);
      
     workSheet.Cells[rowIndex,columnIndex] = dic.Value;
    }
    catch
    {
     this.KillExcelProcess();
     throw new Exception("向單元格[" + dic.Key + "]寫數據出錯！");
    }
   }
  }

// <summary>
/// 設置單元格爲可計算的
/// </summary>
/// <remarks>
/// 如果Excel的單元格格式設置爲數字，日期或者其他類型時，需要設置這些單元格的FormulaR1C1屬性，
/// 否則寫到這些單元格的數據將不會按照預先設定的格式顯示
/// </remarks>
/// <param name="arr">保存單元格的位置索引（行索引和列索引用“,”隔開）和數據</param>
public void SetCells(int sheetIndex,string[] arr)
{
int rowIndex;
int columnIndex;
string position;

if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

if(arr.Length == 0) return;

workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);

for(int i=0;i<arr.Length;i++)
{
try
{
position = arr[i];
rowIndex = Convert.ToInt32(position.Split(',')[0]);
columnIndex = Convert.ToInt32(position.Split(',')[1]);

Excel.Range cell = (Excel.Range)workSheet.Cells[rowIndex,columnIndex];
cell.FormulaR1C1 = cell.Text;
}
catch
{
this.KillExcelProcess();
throw new Exception(string.Format("計算單元格{0}出錯！",arr[i]));
}
}
}

/// <summary>
/// 向單元格寫入數據，對指定WorkSheet操作
/// </summary>
/// <param name="ht">Hashtable的鍵值對保存單元格的位置索引（行索引和列索引用“,”隔開）和數據</param>
public void SetCells(string sheetName,Hashtable ht)
{
int rowIndex;
int columnIndex;
string position;
Excel.Worksheet sheet = null;
int sheetIndex = 0;

if(ht.Count == 0) return;

try
{
for(int i=1;i<=this.WorkSheetCount;i++)
{
workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);

if(workSheet.Name == sheetName)
{
sheet = workSheet;
sheetIndex = workSheet.Index;
}
}

if(sheet != null)
{
foreach(DictionaryEntry dic in ht)
{
try
{
position = dic.Key.ToString();
rowIndex = Convert.ToInt32(position.Split(',')[0]);
columnIndex = Convert.ToInt32(position.Split(',')[1]);

sheet.Cells[rowIndex,columnIndex] = dic.Value;
}
catch
{
this.KillExcelProcess();
throw new Exception("向單元格[" + dic.Key + "]寫數據出錯！");
}
}
}
else
{
this.KillExcelProcess();
throw new Exception("名稱爲/"" + sheetName + "/"的工作表不存在");
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}


/// <summary>
/// 合併單元格，並賦值，對每個WorkSheet操作
/// </summary>
/// <param name="beginRowIndex">開始行索引</param>
/// <param name="beginColumnIndex">開始列索引</param>
/// <param name="endRowIndex">結束行索引</param>
/// <param name="endColumnIndex">結束列索引</param>
/// <param name="text">合併後Range的值</param>
public void MergeCells(int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
{
for(int i=1;i<=this.WorkSheetCount;i++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);
range = workSheet.get_Range(workSheet.Cells[beginRowIndex,beginColumnIndex],workSheet.Cells[endRowIndex,endColumnIndex]);

range.ClearContents(); //先把Range內容清除，合併纔不會出錯
range.MergeCells = true;
range.Value = text;
range.HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter;
range.VerticalAlignment = Excel.XlVAlign.xlVAlignCenter;
}
}

/// <summary>
/// 合併單元格，並賦值，對指定WorkSheet操作
/// </summary>
/// <param name="sheetIndex">WorkSheet索引</param>
/// <param name="beginRowIndex">開始行索引</param>
/// <param name="beginColumnIndex">開始列索引</param>
/// <param name="endRowIndex">結束行索引</param>
/// <param name="endColumnIndex">結束列索引</param>
/// <param name="text">合併後Range的值</param>
public void MergeCells(int sheetIndex,int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);
range = workSheet.get_Range(workSheet.Cells[beginRowIndex,beginColumnIndex],workSheet.Cells[endRowIndex,endColumnIndex]);

range.ClearContents(); //先把Range內容清除，合併纔不會出錯
range.MergeCells = true;
range.Value = text;
range.HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter;
range.VerticalAlignment = Excel.XlVAlign.xlVAlignCenter;
}
#endregion

#region Row Methods
/// <summary>
/// 將指定索引列的數據相同的行合併，對每個WorkSheet操作
/// </summary>
/// <param name="columnIndex">列索引</param>
/// <param name="beginRowIndex">開始行索引</param>
/// <param name="endRowIndex">結束行索引</param>
public void MergeRows(int columnIndex,int beginRowIndex,int endRowIndex)
{
if(endRowIndex - beginRowIndex < 1)
return;

for(int i=1;i<=this.WorkSheetCount;i++)
{
int beginIndex = beginRowIndex;
int count = 0;
string text1;
string text2;
workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(i);

for(int j=beginRowIndex;j<=endRowIndex;j++)
{
range = (Excel.Range)workSheet.Cells[j,columnIndex];
text1 = range.Text.ToString();

range = (Excel.Range)workSheet.Cells[j+1,columnIndex];
text2 = range.Text.ToString();

if(text1 == text2)
{
++count;
}
else
{
if(count > 0)
{
this.MergeCells(workSheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
}

beginIndex = j + 1; //設置開始合併行索引
count = 0; //計數器清0
}

}

}
}


/// <summary>
/// 將指定索引列的數據相同的行合併，對指定WorkSheet操作
/// </summary>
/// <param name="sheetIndex">WorkSheet索引</param>
/// <param name="columnIndex">列索引</param>
/// <param name="beginRowIndex">開始行索引</param>
/// <param name="endRowIndex">結束行索引</param>
public void MergeRows(int sheetIndex,int columnIndex,int beginRowIndex,int endRowIndex)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

if(endRowIndex - beginRowIndex < 1)
return;

int beginIndex = beginRowIndex;
int count = 0;
string text1;
string text2;
workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);

for(int j=beginRowIndex;j<=endRowIndex;j++)
{
range = (Excel.Range)workSheet.Cells[j,columnIndex];
text1 = range.Text.ToString();

range = (Excel.Range)workSheet.Cells[j+1,columnIndex];
text2 = range.Text.ToString();

if(text1 == text2)
{
++count;
}
else
{
if(count > 0)
{
this.MergeCells(workSheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
}

beginIndex = j + 1; //設置開始合併行索引
count = 0; //計數器清0
}

}

}


/// <summary>
/// 插行（在指定行上面插入指定數量行）
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void InsertRows(int rowIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
range = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=0;i<count;i++)
{
range.Insert(Excel.XlDirection.xlDown);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 插行（在指定WorkSheet指定行上面插入指定數量行）
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void InsertRows(int sheetIndex,int rowIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
range = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=0;i<count;i++)
{
range.Insert(Excel.XlDirection.xlDown);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 複製行（在指定行下面複製指定數量行）
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void CopyRows(int rowIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
range1 = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=1;i<=count;i++)
{
range2 = (Excel.Range)workSheet.Rows[rowIndex + i,this.missing];
range1.Copy(range2);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 複製行（在指定WorkSheet指定行下面複製指定數量行）
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void CopyRows(int sheetIndex,int rowIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
range1 = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=1;i<=count;i++)
{
range2 = (Excel.Range)workSheet.Rows[rowIndex + i,this.missing];
range1.Copy(range2);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 刪除行
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void DeleteRows(int rowIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
range = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=0;i<count;i++)
{
range.Delete(Excel.XlDirection.xlDown);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 刪除行
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="rowIndex"></param>
/// <param name="count"></param>
public void DeleteRows(int sheetIndex,int rowIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
range = (Excel.Range)workSheet.Rows[rowIndex,this.missing];

for(int i=0;i<count;i++)
{
range.Delete(Excel.XlDirection.xlDown);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

#endregion

#region Column Methods

/// <summary>
/// 插列（在指定列右邊插入指定數量列）
/// </summary>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void InsertColumns(int columnIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
range = (Excel.Range)workSheet.Columns[this.missing,columnIndex];

for(int i=0;i<count;i++)
{
range.Insert(Excel.XlDirection.xlDown);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 插列（在指定WorkSheet指定列右邊插入指定數量列）
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void InsertColumns(int sheetIndex,int columnIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
range = (Excel.Range)workSheet.Columns[this.missing,columnIndex];

for(int i=0;i<count;i++)
{
range.Insert(Excel.XlDirection.xlDown);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 複製列（在指定列右邊複製指定數量列）
/// </summary>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void CopyColumns(int columnIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
// range1 = (Excel.Range)workSheet.Columns[columnIndex,this.missing];
range1 = (Excel.Range)workSheet.get_Range(this.IntToLetter(columnIndex)+"1",this.IntToLetter(columnIndex)+"10000");

for(int i=1;i<=count;i++)
{
// range2 = (Excel.Range)workSheet.Columns[this.missing,columnIndex + i];
range2 = (Excel.Range)workSheet.get_Range(this.IntToLetter(columnIndex+i)+"1",this.IntToLetter(columnIndex+i)+"10000");
range1.Copy(range2);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 複製列（在指定WorkSheet指定列右邊複製指定數量列）
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void CopyColumns(int sheetIndex,int columnIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
// range1 = (Excel.Range)workSheet.Columns[Type.Missing,columnIndex];
range1 = (Excel.Range)workSheet.get_Range(this.IntToLetter(columnIndex)+"1",this.IntToLetter(columnIndex)+"10000");

for(int i=1;i<=count;i++)
{
// range2 = (Excel.Range)workSheet.Columns[Type.Missing,columnIndex + i];
range2 = (Excel.Range)workSheet.get_Range(this.IntToLetter(columnIndex+i)+"1",this.IntToLetter(columnIndex+i)+"10000");
range1.Copy(range2);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 刪除列
/// </summary>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void DeleteColumns(int columnIndex,int count)
{
try
{
for(int n=1;n<=this.WorkSheetCount;n++)
{
workSheet = (Excel.Worksheet)workBook.Worksheets[n];
range = (Excel.Range)workSheet.Columns[this.missing,columnIndex];

for(int i=0;i<count;i++)
{
range.Delete(Excel.XlDirection.xlDown);
}
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 刪除列
/// </summary>
/// <param name="sheetIndex"></param>
/// <param name="columnIndex"></param>
/// <param name="count"></param>
public void DeleteColumns(int sheetIndex,int columnIndex,int count)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets[sheetIndex];
range = (Excel.Range)workSheet.Columns[this.missing,columnIndex];

for(int i=0;i<count;i++)
{
range.Delete(Excel.XlDirection.xlDown);
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

#endregion

#region Range Methods

/// <summary>
/// 將指定範圍區域拷貝到目標區域
/// </summary>
/// <param name="sheetIndex">WorkSheet索引</param>
/// <param name="startCell">要拷貝區域的開始Cell位置（比如：A10）</param>
/// <param name="endCell">要拷貝區域的結束Cell位置（比如：F20）</param>
/// <param name="targetCell">目標區域的開始Cell位置（比如：H10）</param>
public void RangeCopy(int sheetIndex,string startCell,string endCell,string targetCell)
{
if(sheetIndex > this.WorkSheetCount)
{
this.KillExcelProcess();
throw new Exception("索引超出範圍，WorkSheet索引不能大於WorkSheet數量！");
}

try
{
workSheet = (Excel.Worksheet)workBook.Worksheets.get_Item(sheetIndex);
range1 = workSheet.get_Range(startCell,endCell);
range2 = workSheet.get_Range(targetCell,this.missing);

range1.Copy(range2);
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 將指定範圍區域拷貝到目標區域
/// </summary>
/// <param name="sheetName">WorkSheet名稱</param>
/// <param name="startCell">要拷貝區域的開始Cell位置（比如：A10）</param>
/// <param name="endCell">要拷貝區域的結束Cell位置（比如：F20）</param>
/// <param name="targetCell">目標區域的開始Cell位置（比如：H10）</param>
public void RangeCopy(string sheetName,string startCell,string endCell,string targetCell)
{
try
{
Excel.Worksheet sheet = null;

for(int i=1;i<=this.WorkSheetCount;i++)
{
workSheet = (Excel.Worksheet)workBook.Sheets.get_Item(i);

if(workSheet.Name == sheetName)
{
sheet = workSheet;
}
}

if(sheet != null)
{
for(int i=sheetCount;i>=1;i--)
{
range1 = sheet.get_Range(startCell,endCell);
range2 = sheet.get_Range(targetCell,this.missing);

range1.Copy(range2);
}
}
else
{
this.KillExcelProcess();
throw new Exception("名稱爲/"" + sheetName + "/"的工作表不存在");
}
}
catch(Exception e)
{
this.KillExcelProcess();
throw e;
}
}

/// <summary>
/// 自動填充
/// </summary>
public void RangAutoFill()
{
Excel.Range rng = workSheet.get_Range("B4", Type.Missing);
rng.Value2 = "星期一 ";
rng.AutoFill(workSheet.get_Range("B4","B9"),
Excel.XlAutoFillType.xlFillWeekdays);

rng = workSheet.get_Range("C4", Type.Missing);
rng.Value = "一月";
rng.AutoFill(workSheet.get_Range("C4","C9"),
Excel.XlAutoFillType.xlFillMonths);

rng = workSheet.get_Range("D4",Type.Missing);
rng.Value2 = "1";
rng.AutoFill(workSheet.get_Range("D4","D9"),
Excel.XlAutoFillType.xlFillSeries);

rng = workSheet.get_Range("E4",Type.Missing);
rng.Value2 = "3";
rng = workSheet.get_Range("E5",Type.Missing);
rng.Value2 = "6";
rng = workSheet.get_Range("E4","E5");
rng.AutoFill(workSheet.get_Range("E4","E9"),
Excel.XlAutoFillType.xlFillSeries);

}

/// <summary>
/// 應用樣式
/// </summary>
public void ApplyStyle()
{
object missingValue = Type.Missing;
Excel.Range rng = workSheet.get_Range("B3","L23");
Excel.Style style;

try
{
style = workBook.Styles["NewStyle"];
}
// Style doesn't exist yet.
catch
{
style = workBook.Styles.Add("NewStyle", missingValue);
style.Font.Name = "Verdana";
style.Font.Size = 12;
style.Font.Color = 255;
style.Interior.Color = (200 << 16) | (200 << 8) | 200;
style.Interior.Pattern = Excel.XlPattern.xlPatternSolid;
}

rng.Value2 = "'Style Test";
rng.Style = "NewStyle";
rng.Columns.AutoFit();
}

#endregion

#region ExcelHelper Kit
/// <summary>
/// 將Excel列的字母索引值轉換成整數索引值
/// </summary>
/// <param name="letter"></param>
/// <returns></returns>
public int LetterToInt(string letter)
{
int n = 0;

if(letter.Trim().Length == 0)
throw new Exception("不接受空字符串！");

if(letter.Length >= 2)
{
char c1 = letter.ToCharArray(0,2)[0];
char c2 = letter.ToCharArray(0,2)[1];

if(!char.IsLetter(c1) || !char.IsLetter(c2))
{
throw new Exception("格式不正確，必須是字母！");
}

c1 = char.ToUpper(c1);
c2 = char.ToUpper(c2);

int i = Convert.ToInt32(c1) - 64;
int j = Convert.ToInt32(c2) - 64;

n = i * 26 + j;
}

if(letter.Length == 1)
{
char c1 = letter.ToCharArray()[0];

if(!char.IsLetter(c1))
{
throw new Exception("格式不正確，必須是字母！");
}

c1 = char.ToUpper(c1);

n = Convert.ToInt32(c1) - 64;
}

if(n > 256)
throw new Exception("索引超出範圍，Excel的列索引不能超過256！");

return n;
}

/// <summary>
/// 將Excel列的整數索引值轉換爲字符索引值
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public string IntToLetter(int n)
{
if(n > 256)
throw new Exception("索引超出範圍，Excel的列索引不能超過256！");

int i = Convert.ToInt32(n / 26);
int j = n % 26;

char c1 = Convert.ToChar( i + 64 );
char c2 = Convert.ToChar( j + 64 );

if(n > 26)
return c1.ToString() + c2.ToString();
else if(n == 26)
return "Z";
else
return c2.ToString();
}

#endregion

#region Output File(注意：如果目標文件已存在的話會出錯)
/// <summary>
/// 輸出Excel文件並退出
/// </summary>
public void OutputExcelFile()
{
if(this.outputFile == null)
throw new Exception("沒有指定輸出文件路徑！");

try
{
workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 輸出指定格式的文件（支持格式：HTML，CSV，TEXT，EXCEL）
/// </summary>
/// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
public void OutputFile(string format)
{
if(this.outputFile == null)
throw new Exception("沒有指定輸出文件路徑！");

try
{
switch(format)
{
case "HTML":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "CSV":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlCSV,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "TEXT":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
// case "XML":
// {
// workBook.SaveAs(outputFile,Excel.XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
// Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange,
// Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
// break;
//
// }
default:
{
workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
}
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 保存文件
/// </summary>
public void SaveFile()
{
try
{
workBook.Save();
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 另存文件
/// </summary>
public void SaveAsFile()
{
if(this.outputFile == null)
throw new Exception("沒有指定輸出文件路徑！");

try
{
workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 將Excel文件另存爲指定格式
/// </summary>
/// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
public void SaveAsFile(string format)
{
if(this.outputFile == null)
throw new Exception("沒有指定輸出文件路徑！");

try
{
switch(format)
{
case "HTML":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "CSV":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlCSV,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "TEXT":
{
workBook.SaveAs(outputFile,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
// case "XML":
// {
// workBook.SaveAs(outputFile,Excel.XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
// Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange,
// Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
// break;
// }
default:
{
workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
}
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 另存文件
/// </summary>
/// <param name="fileName">文件名</param>
public void SaveFile(string fileName)
{
try
{
workBook.SaveAs(fileName,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}

/// <summary>
/// 將Excel文件另存爲指定格式
/// </summary>
/// <param name="fileName">文件名</param>
/// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
public void SaveAsFile(string fileName,string format)
{
try
{
switch(format)
{
case "HTML":
{
workBook.SaveAs(fileName,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "CSV":
{
workBook.SaveAs(fileName,Excel.XlFileFormat.xlCSV,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
case "TEXT":
{
workBook.SaveAs(fileName,Excel.XlFileFormat.xlHtml,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
// case "XML":
// {
// workBook.SaveAs(fileName,Excel.XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
// Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange,
// Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
// break;
// }
default:
{
workBook.SaveAs(fileName,missing,missing,missing,missing,missing,Excel.XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
break;
}
}
}
catch(Exception e)
{
throw e;
}
finally
{
this.Dispose();
}
}
#endregion

#endregion

#region 私有方法

/// <summary>
/// 合併單元格，並賦值，對指定WorkSheet操作
/// </summary>
/// <param name="beginRowIndex">開始行索引</param>
/// <param name="beginColumnIndex">開始列索引</param>
/// <param name="endRowIndex">結束行索引</param>
/// <param name="endColumnIndex">結束列索引</param>
/// <param name="text">合併後Range的值</param>
private void MergeCells(Excel.Worksheet sheet,int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
{
if(sheet == null)
return;

range = sheet.get_Range(sheet.Cells[beginRowIndex,beginColumnIndex],sheet.Cells[endRowIndex,endColumnIndex]);

range.ClearContents(); //先把Range內容清除，合併纔不會出錯
range.MergeCells = true;
range.Value = text;
range.HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter;
range.VerticalAlignment = Excel.XlVAlign.xlVAlignCenter;
}

/// <summary>
/// 將指定索引列的數據相同的行合併，對指定WorkSheet操作
/// </summary>
/// <param name="columnIndex">要合併的列索引</param>
/// <param name="beginRowIndex">合併開始行索引</param>
/// <param name="rows">要合併的行數</param>
private void MergeRows(Excel.Worksheet sheet,int columnIndex,int beginRowIndex,int rows)
{
int beginIndex = beginRowIndex;
int count = 0;
string text1;
string text2;

if(sheet == null)
return;

for(int j=beginRowIndex;j<beginRowIndex+rows;j++)
{
range1 = (Excel.Range)sheet.Cells[j,columnIndex];
range2 = (Excel.Range)sheet.Cells[j+1,columnIndex];
text1 = range1.Text.ToString();
text2 = range2.Text.ToString();

if(text1 == text2)
{
++count;
}
else
{
if(count > 0)
{
this.MergeCells(sheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
}

beginIndex = j + 1; //設置開始合併行索引
count = 0; //計數器清0
}

}

}


/// <summary>
/// 計算WorkSheet數量
/// </summary>
/// <param name="rowCount">記錄總行數</param>
/// <param name="rows">每WorkSheet行數</param>
public int GetSheetCount(int rowCount,int rows)
{
int n = rowCount % rows; //餘數

if(n == 0)
return rowCount / rows;
else
return Convert.ToInt32(rowCount / rows) + 1;
}

/// <summary>
/// 結束Excel進程
/// </summary>
public void KillExcelProcess()
{
Process[] myProcesses;
DateTime startTime;
myProcesses = Process.GetProcessesByName("Excel");

//得不到Excel進程ID，暫時只能判斷進程啓動時間
foreach(Process myProcess in myProcesses)
{
startTime = myProcess.StartTime;

if(startTime > beforeTime && startTime < afterTime)
{
myProcess.Kill();
}
}
}


private void Dispose()
{
workBook.Close(null,null,null);
app.Workbooks.Close();
app.Quit();

if(range != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(range);
range = null;
}
if(range1 != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(range1);
range1 = null;
}
if(range2 != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(range2);
range2 = null;
}
if(textBox != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(textBox);
textBox = null;
}
if(workSheet != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(workSheet);
workSheet = null;
}
if(workBook != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(workBook);
workBook = null;
}
if(app != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(app);
app = null;
}

GC.Collect();

this.KillExcelProcess();

}//end Dispose
#endregion


}//end class
}//end namespace

CQBSBJIANXY
發佈了58 篇原創文章 · 獲贊 3 · 訪問量 18萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

界面組件DevExpress Office File API - 如何用OpenAI增強文檔可訪問性（二）

DevExpress Office File API是一個專爲C#, VB.NET 和 ASP.NET等開發人員提供的非可視化.NET庫。有了這個庫，不用安裝Microsoft Office，就可以完全自動處理Excel、Word等文檔。開

原創 2024-06-14 12:16:46

界面控件DevExpress WinForms垂直&屬性網格組件 - 擁有更靈活的UI選擇（一）

DevExpress WinForms垂直&屬性網格組件旨在提供UI靈活性，它允許用戶顯示數據集中的單個行或在其90度倒置網格容器中顯示多行數據集。另外，用戶可以把它用作一個屬性網格，就像在Visual Studio IDE中那樣。 P.S

原創 2024-06-12 12:16:57

VCL界面組件DevExpress VCL v23.2 - 圖表控件增強

DevExpress VCL是DevExpress公司旗下最老牌的用戶界面套包，所包含的控件有：數據錄入、圖表、數據分析、導航、佈局等。該控件能幫助您創建優異的用戶體驗，提供高影響力的業務解決方案，並利用您現有的VCL技能爲未來構建下一代應

原創 2024-06-07 12:16:51

WinForm應用實戰開發指南 - 表格數據錄入問題解析

一般來說，錄入數據的時候，我們都採用在一個窗體界面中，根據不同內容進行錄入。但是有時候涉及主從表的數據錄入，從表的數據有時候爲了錄入方便，也會通過表格控件直接錄入。在Winform開發的時候，我們很多時候可以利用表格GridControl控

界面開發小八哥 2024-06-11 12:18:15

VS代碼生成工具ReSharper v2024.1全新發布——改進對C#的支持

實質上，ReSharper特徵可用於C#，VB.net，XML，Asp.net，XAML，和構建腳本。 使用ReSharper，你可以進行深度代碼分析，智能代碼協助，實時錯誤代碼高亮顯示，解決方案範圍內代碼分析，快速代碼更正，一步完成代碼格

原創 2024-06-07 12:16:50

redis的key亂碼問題和值自增問題

背景 今天在使用redis做分佈式緩存提供自增id的時候,發現了�� t Goods_key_37的亂碼問題;因爲存的是Long,然後我就自定義了一個RedisTemplate<string,long>的實例來使用 解決過程 1.剛開始說

原創 2024-06-14 10:11:25

一文搞懂5種內存溢出案例，內含完整源碼

本文分享自華爲雲社區《10分鐘搞懂各種內存溢出案例！！（含完整源碼，建議收藏）》，作者：冰 河。 作爲程序員，多多少少都會遇到一些內存溢出的場景，如果你還沒遇到，說明你工作的年限可能比較短，或者你根本就是個假程序員！哈哈，開個玩笑。今天，我

原創 2024-06-05 10:56:55

標籤批量打印軟件中如何製作日期開頭的隨機號條形碼

       製作日期開頭的隨機號條形碼，比如2023-11-02-KH-0902，其中前面的“2023-11-02”是打印的時候調用電腦系統時間進行打印的，“-KH-”是固定不變的內容，後面的“0902”是四位隨機號，可以在標籤批量打印軟

原創 2024-06-14 02:09:42

如何處理Excel表數據右側的空白符進行批量打印標籤

       最近在批量打印標籤的時候遇到了一個這樣的問題：Excel表數據中有些數據右側有一些空白符（空字符串），導入到中琅標籤製作軟件中之後，即便使用了“修剪空白”處理方法進行修剪右端不可見字符，數據右側的空白符還是處理不了，在軟件中會

原創 2024-06-14 02:09:36

如何使用前端表格控件實現數據更新？

前言 小編之前分享過一篇文章叫《如何使用前端表格控件實現多數據源整合？》（可以放上文章的鏈接）。今天，繼續爲大家介紹如何使用前端表格控件來更新已連接的數據源信息。 環境準備 SpreadJS在線表格編輯器： SpreadJS 前端表格控件新

原創 2024-06-11 10:45:05

盤點一個Pandas數據分組的問題

大家好，我是Python進階者。 一、前言 前幾天在Python白銀交流羣【上海新年人】問了一個Pandas數據分組的問題，問題如下： list1 = '電子稅票號碼 徵收稅務機關 社保經辦機構 單位編號 費種 徵收品目 徵收子目 費款所屬

原創 2024-06-07 10:02:02

對spring事務的理解

作者：天空小小 爲啥要寫？ 從我接觸spring事務開始，就覺得這個東西很神奇，感覺實現很混亂，總是各種新的用法層出不窮。雖然懵懵懂懂的覺

原創 2024-06-16 02:11:44

一文搞懂 Spring 循環依賴

這個其實是一個特別高頻的面試題，松哥也一直很想和大家仔細來聊一聊這個話題，網上關於這塊的文章很多，但是我一直覺得要把這個問題講清楚還有點難度，今天我來試一試，看能不能和小夥伴們把這個問題梳理清楚，當然，如果小夥伴們覺得看文章不過癮，松哥也有

原創 2024-06-06 13:11:47

8個實用的Java Streams API

分享8個開箱即用的API，方便日常處理集合。 1. 快速過濾空值：Stream.ofNullable 該方法是在 Java 9 中引入的，有助於過濾集合中的所有空值，從而可能使我們避免空指針異常。 在下面的示例中，有一個包含 null 的L

原創 2024-06-04 21:46:09

記一次疑似JVM內存泄漏的排查過程

一、背景 在日常部門OpsReview過程中，部門內多次遇到應用容器所在的宿主機磁盤繁忙導致的接口響應緩慢，TP99增高等影響服務性能的問題，其中比較有效的解決方案是開啓日誌的異步打印，可以有效避免同步日誌打印在磁盤IO高起的情況下拖慢業

原創 2024-06-04 12:09:32