• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

c#excel

原作者: [db:作者] 来自: [db:来源] 收藏 邀请
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模板中设置好   
    /// 作    者:lingyun_k   
    /// 创建日期:2005-7-12   
    /// </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(Exc 

鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
c#连接sql语句之拼接字符串单引号双引号问题发布时间:2022-07-10
下一篇:
C#里判断字符串是否为纯数字【转载】发布时间:2022-07-10
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap