开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > .net编程 > 查看源码
ExcelFly.cs
资源名称：whpower2007-8-24.rar　[点击查看]
上传用户：tiancihang
上传日期：2014-03-12
资源大小：21387k
文件大小：64k
源码类别：

.net编程

开发平台：

C#

ExcelFly.cs：源码内容
  1. using System;
  2. using System.IO;
  3. using System.Text;
  4. using System.Data;
  5. using System.Reflection;
  6. using System.Diagnostics;
  7. using System.Collections;
  8. using Microsoft.Office;
  9. using Microsoft.Office.Interop.Excel;
  10. //using cfg = System.Configuration;
  12. namespace com.etong.Excel
  13. {
  14. /// <summary>
  15. /// 说    明：Excel输出打印模块
  16. ///   暂时不提供操作Excel对象样式方法，样式可以在Excel模板中设置好
  17. /// 作    者：flychou x
  18. /// 创建日期：2007－8－15
  19. /// </summary>
  20. public class EtongExcel
  21. {
  23. #region 成员变量
  24. private string templetFile = null;
  25. private string outputFile = null;
  26. private object missing = Missing.Value;
  27. private DateTime beforeTime; //Excel启动之前时间
  28. private DateTime afterTime; //Excel启动之后时间
  29.         
  30.          
  31. Application app;
  32. Workbook workBook;
  33. Worksheet workSheet;
  34. Range range;
  35. Range range1;
  36. Range range2;
  37. TextBox textBox;
  38. private int sheetCount = 1; //WorkSheet数量
  39. private string sheetPrefixName = "页";
  40. #endregion
  42. #region 公共属性
  43. /// <summary>
  44. /// WorkSheet前缀名，比如：前缀名为“页”，那么WorkSheet名称依次为“页-1，页-2...”
  45. /// </summary>
  46. public string SheetPrefixName
  47. {
  48. set { this.sheetPrefixName = value; }
  49. }
  51. /// <summary>
  52. /// WorkSheet数量
  53. /// </summary>
  54. public int WorkSheetCount
  55. {
  56. get { return workBook.Sheets.Count; }
  57. }
  59. /// <summary>
  60. /// Excel模板文件路径
  61. /// </summary>
  62. public string TempletFilePath
  63. {
  64. set { this.templetFile = value; }
  65. }
  67. /// <summary>
  68. /// 输出Excel文件路径
  69. /// </summary>
  70. public string OutputFilePath
  71. {
  72. set { this.outputFile = value; }
  73. }
  74. #endregion
  76. #region 公共方法
  78. #region ExcelHelper
  79. /// <summary>
  80. /// 构造函数，将一个已有Excel工作簿作为模板，并指定输出路径
  81. /// </summary>
  82. /// <param name="templetFilePath">Excel模板文件路径</param>
  83. /// <param name="outputFilePath">输出Excel文件路径</param>
  84. public EtongExcel(string templetFilePath,string outputFilePath)
  85. {
  86. if(templetFilePath == null)
  87. throw new Exception("Excel模板文件路径不能为空！");
  89. if(outputFilePath == null)
  90. throw new Exception("输出Excel文件路径不能为空！");
  92. if(!File.Exists(templetFilePath))
  93. throw new Exception("指定路径的Excel模板文件不存在！");
  95. this.templetFile = templetFilePath;
  96. this.outputFile = outputFilePath;
  98. //创建一个Application对象并使其可见
  99. beforeTime = DateTime.Now;
  100. app = new ApplicationClass();
  101.            // app.Visible = true;
  102. afterTime = DateTime.Now;
  104. //打开模板文件，得到WorkBook对象
  105.             workBook = app.Workbooks.Open(templetFile, missing, missing, missing, missing, missing,
  106.                 missing, missing, missing, missing, missing, missing, missing, missing, missing);
  108.             //workBook = app.Workbooks.Open(templetFile,missing,missing,missing,missing,missing,
  109.             //    missing,missing,missing,missing,missing,missing,missing);
  111. //得到WorkSheet对象
  112. workSheet = (Worksheet)workBook.Sheets.get_Item(1);
  114. }
  116. /// <summary>
  117. /// 构造函数，打开一个已有的工作簿
  118. /// </summary>
  119. /// <param name="fileName">Excel文件名</param>
  120. public EtongExcel(string fileName)
  121. {
  122. if(!File.Exists(fileName))
  123. throw new Exception("指定路径的Excel文件不存在！");
  125. //创建一个Application对象并使其可见
  126. beforeTime = DateTime.Now;
  127.             app = new ApplicationClass();
  128.             //app.Visible = true;
  129. afterTime = DateTime.Now;
  131. //打开一个WorkBook
  132. workBook = app.Workbooks.Open(fileName,
  133. Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  134. Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  135. Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  136.                 Type.Missing,Type.Missing);
  138. //得到WorkSheet对象
  139. workSheet = (Worksheet)workBook.Sheets.get_Item(1);
  141. }
  143. /// <summary>
  144. /// 构造函数，新建一个工作簿
  145. /// </summary>
  146.         public EtongExcel()
  147. {
  148. //创建一个Application对象并使其可见
  149. beforeTime = DateTime.Now;
  150. app = new ApplicationClass();
  151. app.Visible = true;
  152. afterTime = DateTime.Now;
  154. //新建一个WorkBook
  155. workBook = app.Workbooks.Add(Type.Missing);
  157. //得到WorkSheet对象
  158. workSheet = (Worksheet)workBook.Sheets.get_Item(1);
  160. }
  161. #endregion
  163. #region Data Export Methods
  165. /// <summary>
  166. /// 将DataTable数据写入Excel文件（自动分页）
  167. /// </summary>
  168. /// <param name="dt">DataTable</param>
  169. /// <param name="rows">每个WorkSheet写入多少行数据</param>
  170. /// <param name="top">表格数据起始行索引</param>
  171. /// <param name="left">表格数据起始列索引</param>
  172. public void DataTableToExcel(Microsoft.Office.Interop.Excel.DataTable dt,int rows,int top,int left)
  173. {
  174. int rowCount = dt.Application.Rows.Count; //DataTable行数
  175.             int colCount = dt.Application.Columns.Count; //DataTable列数
  176. sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet个数
  177. // StringBuilder sb;
  179. //复制sheetCount-1个WorkSheet对象
  180. for(int i=1;i<sheetCount;i++)
  181. {
  182. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  183. workSheet.Copy(missing,workBook.Worksheets[i]);
  184. }
  186. for(int i=1;i<=sheetCount;i++)
  187. {
  188. int startRow = (i - 1) * rows; //记录起始行索引
  189. int endRow = i * rows; //记录结束行索引
  191. //若是最后一个WorkSheet，那么记录结束行索引为源DataTable行数
  192. if(i == sheetCount)
  193. endRow = rowCount;
  195. //获取要写入数据的WorkSheet对象，并重命名
  196. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  197. workSheet.Name = sheetPrefixName + "-" + i.ToString();
  199. //将dt中的数据写入WorkSheet
  200. // for(int j=0;j<endRow-startRow;j++)
  201. // {
  202. // for(int k=0;k<colCount;k++)
  203. // {
  204. // workSheet.Cells[top + j,left + k] = dt.Rows[startRow + j][k].ToString();
  205. // }
  206. // }
  208. //利用二维数组批量写入
  209. int row = endRow-startRow;
  210. string[,] ss = new string[row,colCount];
  212. for(int j=0;j<row;j++)
  213. {
  214. for(int k=0;k<colCount;k++)
  215. {
  216. ss[j,k] = dt.Application.Rows[startRow + j,k].ToString();
  217. }
  218. }
  220. range = (Range)workSheet.Cells[top,left];
  221. range = range.get_Resize(row,colCount);
  222. range.Value2 = ss;
  224. #region 利用Windwo粘贴板批量拷贝数据（在Web下面行不通）
  225. /*sb = new StringBuilder();
  227. for(int j=0;j<endRow-startRow;j++)
  228. {
  229. for(int k=0;k<colCount;k++)
  230. {
  231. sb.Append( dt.Rows[startRow + j][k].ToString() );
  232. sb.Append("t");
  233. }
  235. sb.Append("n");
  236. }
  238. System.Windows.Forms.Clipboard.SetDataObject(sb.ToString());
  240. range = (Excel.Range)workSheet.Cells[top,left];
  241. workSheet.Paste(range,false);*/
  242. #endregion
  244. }
  245. }
  248. /// <summary>
  249. /// 将DataTable数据写入Excel文件（不分页）
  250. /// </summary>
  251. /// <param name="dt">DataTable</param>
  252. /// <param name="top">表格数据起始行索引</param>
  253. /// <param name="left">表格数据起始列索引</param>
  254. public void DataTableToExcel(Microsoft.Office.Interop.Excel.DataTable dt,int top,int left)
  255. {
  256. int rowCount = dt.Application.Rows.Count; //DataTable行数
  257. int colCount = dt.Application.Columns.Count; //DataTable列数
  259. //利用二维数组批量写入
  260. string[,] arr = new string[rowCount,colCount];
  262. for(int j=0;j<rowCount;j++)
  263. {
  264. for(int k=0;k<colCount;k++)
  265. {
  266. arr[j,k] = dt.Application.Rows[j,k].ToString();
  267. }
  268. }
  270. range = (Range)workSheet.Cells[top,left];
  271. range = range.get_Resize(rowCount,colCount);
  272. range.Value2 = arr;
  273. }
  276. /// <summary>
  277. /// 将DataTable数据写入Excel文件（自动分页，并指定要合并的列索引）
  278. /// </summary>
  279. /// <param name="dt">DataTable</param>
  280. /// <param name="rows">每个WorkSheet写入多少行数据</param>
  281. /// <param name="top">表格数据起始行索引</param>
  282. /// <param name="left">表格数据起始列索引</param>
  283. /// <param name="mergeColumnIndex">DataTable中要合并相同行的列索引，从0开始</param>
  284. public void DataTableToExcel(Microsoft.Office.Interop.Excel.DataTable dt,int rows,int top,int left,int mergeColumnIndex)
  285. {
  286. int rowCount = dt.Application.Rows.Count; //源DataTable行数
  287. int colCount = dt.Application.Columns.Count; //源DataTable列数
  288. sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet个数
  289. // StringBuilder sb;
  291. //复制sheetCount-1个WorkSheet对象
  292. for(int i=1;i<sheetCount;i++)
  293. {
  294. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  295. workSheet.Copy(missing,workBook.Worksheets[i]);
  296. }
  298. for(int i=1;i<=sheetCount;i++)
  299. {
  300. int startRow = (i - 1) * rows; //记录起始行索引
  301. int endRow = i * rows; //记录结束行索引
  303. //若是最后一个WorkSheet，那么记录结束行索引为源DataTable行数
  304. if(i == sheetCount)
  305. endRow = rowCount;
  307. //获取要写入数据的WorkSheet对象，并重命名
  308. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  309. workSheet.Name = sheetPrefixName + "-" + i.ToString();
  311. //将dt中的数据写入WorkSheet
  312. // for(int j=0;j<endRow-startRow;j++)
  313. // {
  314. // for(int k=0;k<colCount;k++)
  315. // {
  316. // workSheet.Cells[top + j,left + k] = dt.Rows[startRow + j][k].ToString();
  317. // }
  318. // }
  320. //利用二维数组批量写入
  321. int row = endRow-startRow;
  322. string[,] ss = new string[row,colCount];
  324. for(int j=0;j<row;j++)
  325. {
  326. for(int k=0;k<colCount;k++)
  327. {
  328. ss[j,k] = dt.Application.Rows[startRow + j,k].ToString();
  329. }
  330. }
  332. range = (Range)workSheet.Cells[top,left];
  333. range = range.get_Resize(row,colCount);
  334. range.Value2 = ss;
  336. //合并相同行
  337. this.MergeRows(workSheet,left+mergeColumnIndex,top,rows);
  339. }
  340. }
  343. /// <summary>
  344. /// 将二维数组数据写入Excel文件（自动分页）
  345. /// </summary>
  346. /// <param name="arr">二维数组</param>
  347. /// <param name="rows">每个WorkSheet写入多少行数据</param>
  348. /// <param name="top">行索引</param>
  349. /// <param name="left">列索引</param>
  350. public void ArrayToExcel(string[,] arr,int rows,int top,int left)
  351. {
  352. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  353. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  354. sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet个数
  356. //复制sheetCount-1个WorkSheet对象
  357. for(int i=1;i<sheetCount;i++)
  358. {
  359. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  360. workSheet.Copy(missing,workBook.Worksheets[i]);
  361. }
  363. //将二维数组数据写入Excel
  364. for(int i=sheetCount;i>=1;i--)
  365. {
  366. int startRow = (i - 1) * rows; //记录起始行索引
  367. int endRow = i * rows; //记录结束行索引
  369. //若是最后一个WorkSheet，那么记录结束行索引为源DataTable行数
  370. if(i == sheetCount)
  371. endRow = rowCount;
  373. //获取要写入数据的WorkSheet对象，并重命名
  374. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  375. workSheet.Name = sheetPrefixName + "-" + i.ToString();
  377. //将二维数组中的数据写入WorkSheet
  378. // for(int j=0;j<endRow-startRow;j++)
  379. // {
  380. // for(int k=0;k<colCount;k++)
  381. // {
  382. // workSheet.Cells[top + j,left + k] = arr[startRow + j,k];
  383. // }
  384. // }
  386. //利用二维数组批量写入
  387. int row = endRow-startRow;
  388. string[,] ss = new string[row,colCount];
  390. for(int j=0;j<row;j++)
  391. {
  392. for(int k=0;k<colCount;k++)
  393. {
  394. ss[j,k] = arr[startRow + j,k];
  395. }
  396. }
  398. range = (Range)workSheet.Cells[top,left];
  399. range = range.get_Resize(row,colCount);
  400. range.Value2 = ss;
  401. }
  403. }//end ArrayToExcel
  406. /// <summary>
  407. /// 将二维数组数据写入Excel文件（不分页）
  408. /// </summary>
  409. /// <param name="arr">二维数组</param>
  410. /// <param name="top">行索引</param>
  411. /// <param name="left">列索引</param>
  412. public void ArrayToExcel(string[,] arr,int top,int left)
  413. {
  414. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  415. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  417. range = (Range)workSheet.Cells[top,left];
  418. range = range.get_Resize(rowCount,colCount);
  419. range.FormulaArray = arr;
  421. }//end ArrayToExcel
  423. /// <summary>
  424. /// 将二维数组数据写入Excel文件（不分页）
  425. /// </summary>
  426. /// <param name="arr">二维数组</param>
  427. /// <param name="top">行索引</param>
  428. /// <param name="left">列索引</param>
  429. /// <param name="isFormula">填充的数据是否需要计算</param>
  430. public void ArrayToExcel(string[,] arr,int top,int left,bool isFormula)
  431. {
  432. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  433. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  435. range = (Range)workSheet.Cells[top,left];
  436. range = range.get_Resize(rowCount,colCount);
  438. //注意：使用range.FormulaArray写合并的单元格会出问题
  439. if(isFormula)
  440. range.FormulaArray = arr;
  441. else
  442. range.Value2 = arr;
  444. }//end ArrayToExcel
  446. /// <summary>
  447. /// 将二维数组数据写入Excel文件（不分页），合并指定列的相同行
  448. /// </summary>
  449. /// <param name="arr">二维数组</param>
  450. /// <param name="top">行索引</param>
  451. /// <param name="left">列索引</param>
  452. /// <param name="isFormula">填充的数据是否需要计算</param>
  453. /// <param name="mergeColumnIndex">需要合并行的列索引</param>
  454. public void ArrayToExcel(string[,] arr,int top,int left,bool isFormula,int mergeColumnIndex)
  455. {
  456. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  457. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  459. range = (Range)workSheet.Cells[top,left];
  460. range = range.get_Resize(rowCount,colCount);
  462. //注意：使用range.FormulaArray写合并的单元格会出问题
  463. if(isFormula)
  464. range.FormulaArray = arr;
  465. else
  466. range.Value2 = arr;
  468. this.MergeRows(workSheet,mergeColumnIndex,top,rowCount);
  470. }//end ArrayToExcel
  472. /// <summary>
  473. /// 将二维数组数据写入Excel文件（不分页）
  474. /// </summary>
  475. /// <param name="sheetIndex">工作表索引</param>
  476. /// <param name="arr">二维数组</param>
  477. /// <param name="top">行索引</param>
  478. /// <param name="left">列索引</param>
  479. public void ArrayToExcel(int sheetIndex,string[,] arr,int top,int left)
  480. {
  481. if(sheetIndex > this.WorkSheetCount)
  482. {
  483. this.KillExcelProcess();
  484. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  485. }
  487. // 改变当前工作表
  488. this.workSheet = (Worksheet)this.workBook.Sheets.get_Item(sheetIndex);
  490. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  491. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  493. range = (Range)workSheet.Cells[top,left];
  494. range = range.get_Resize(rowCount,colCount);
  496. range.Value2 = arr;
  498. }//end ArrayToExcel
  500. /// <summary>
  501. /// 将二维数组数据写入Excel文件（自动分页，并指定要合并的列索引）
  502. /// </summary>
  503. /// <param name="arr">二维数组</param>
  504. /// <param name="rows">每个WorkSheet写入多少行数据</param>
  505. /// <param name="top">行索引</param>
  506. /// <param name="left">列索引</param>
  507. /// <param name="mergeColumnIndex">数组的二维索引，相当于DataTable的列索引，索引从0开始</param>
  508. public void ArrayToExcel(string[,] arr,int rows,int top,int left,int mergeColumnIndex)
  509. {
  510. int rowCount = arr.GetLength(0); //二维数组行数（一维长度）
  511. int colCount = arr.GetLength(1); //二维数据列数（二维长度）
  512. sheetCount = this.GetSheetCount(rowCount,rows); //WorkSheet个数
  514. //复制sheetCount-1个WorkSheet对象
  515. for(int i=1;i<sheetCount;i++)
  516. {
  517. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  518. workSheet.Copy(missing,workBook.Worksheets[i]);
  519. }
  521. //将二维数组数据写入Excel
  522. for(int i=sheetCount;i>=1;i--)
  523. {
  524. int startRow = (i - 1) * rows; //记录起始行索引
  525. int endRow = i * rows; //记录结束行索引
  527. //若是最后一个WorkSheet，那么记录结束行索引为源DataTable行数
  528. if(i == sheetCount)
  529. endRow = rowCount;
  531. //获取要写入数据的WorkSheet对象，并重命名
  532. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  533. workSheet.Name = sheetPrefixName + "-" + i.ToString();
  535. //将二维数组中的数据写入WorkSheet
  536. for(int j=0;j<endRow-startRow;j++)
  537. {
  538. for(int k=0;k<colCount;k++)
  539. {
  540. workSheet.Cells[top + j,left + k] = arr[startRow + j,k];
  541. }
  542. }
  544. //利用二维数组批量写入
  545. int row = endRow-startRow;
  546. string[,] ss = new string[row,colCount];
  548. for(int j=0;j<row;j++)
  549. {
  550. for(int k=0;k<colCount;k++)
  551. {
  552. ss[j,k] = arr[startRow + j,k];
  553. }
  554. }
  556. range = (Range)workSheet.Cells[top,left];
  557. range = range.get_Resize(row,colCount);
  558. range.Value2 = ss;
  560. //合并相同行
  561. this.MergeRows(workSheet,left+mergeColumnIndex,top,rows);
  562. }
  564. }//end ArrayToExcel
  565. #endregion
  567. #region WorkSheet Methods
  569. /// <summary>
  570. /// 改变当前工作表
  571. /// </summary>
  572. /// <param name="sheetIndex">工作表索引</param>
  573. public void ChangeCurrentWorkSheet(int sheetIndex)
  574. {
  575. //若指定工作表索引超出范围，则不改变当前工作表
  576. if(sheetIndex < 1)
  577. return;
  579. if(sheetIndex > this.WorkSheetCount)
  580. return;
  582. this.workSheet = (Worksheet)this.workBook.Sheets.get_Item(sheetIndex);
  583. }
  584. /// <summary>
  585. /// 隐藏指定名称的工作表
  586. /// </summary>
  587. /// <param name="sheetName">工作表名称</param>
  588. public void HiddenWorkSheet(string sheetName)
  589. {
  590. try
  591. {
  592. Worksheet sheet = null;
  594. for(int i=1;i<=this.WorkSheetCount;i++)
  595. {
  596. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  598. if(workSheet.Name == sheetName)
  599. sheet = workSheet;
  600. }
  602. if(sheet != null)
  603. sheet.Visible = XlSheetVisibility.xlSheetHidden;
  604. else
  605. {
  606. this.KillExcelProcess();
  607. throw new Exception("名称为"" + sheetName + ""的工作表不存在");
  608. }
  609. }
  610. catch(Exception e)
  611. {
  612. this.KillExcelProcess();
  613. throw e;
  614. }
  615. }
  617. /// <summary>
  618. /// 隐藏指定索引的工作表
  619. /// </summary>
  620. /// <param name="sheetIndex"></param>
  621. public void HiddenWorkSheet(int sheetIndex)
  622. {
  623. if(sheetIndex > this.WorkSheetCount)
  624. {
  625. this.KillExcelProcess();
  626. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  627. }
  629. try
  630. {
  631. Worksheet sheet = null;
  632. sheet = (Worksheet)workBook.Sheets.get_Item(sheetIndex);
  634. sheet.Visible = XlSheetVisibility.xlSheetHidden;
  635. }
  636. catch(Exception e)
  637. {
  638. this.KillExcelProcess();
  639. throw e;
  640. }
  641. }
  644. /// <summary>
  645. /// 在指定名称的工作表后面拷贝指定个数的该工作表的副本，并重命名
  646. /// </summary>
  647. /// <param name="sheetName">工作表名称</param>
  648. /// <param name="sheetCount">工作表个数</param>
  649. public void CopyWorkSheets(string sheetName,int sheetCount)
  650. {
  651. try
  652. {
  653. Worksheet sheet = null;
  654. int sheetIndex = 0;
  656. for(int i=1;i<=this.WorkSheetCount;i++)
  657. {
  658. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  660. if(workSheet.Name == sheetName)
  661. {
  662. sheet = workSheet;
  663. sheetIndex = workSheet.Index;
  664. }
  665. }
  667. if(sheet != null)
  668. {
  669. for(int i=sheetCount;i>=1;i--)
  670. {
  671. sheet.Copy(this.missing,sheet);
  672. }
  674. //重命名
  675. for(int i=sheetIndex;i<=sheetIndex+sheetCount;i++)
  676. {
  677. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  678. workSheet.Name = sheetName + "-" + Convert.ToString(i - sheetIndex + 1);
  679. }
  680. }
  681. else
  682. {
  683. this.KillExcelProcess();
  684. throw new Exception("名称为"" + sheetName + ""的工作表不存在");
  685. }
  686. }
  687. catch(Exception e)
  688. {
  689. this.KillExcelProcess();
  690. throw e;
  691. }
  692. }
  694. /// <summary>
  695. /// 将一个工作表拷贝到另一个工作表后面，并重命名
  696. /// </summary>
  697. /// <param name="srcSheetIndex">拷贝源工作表索引</param>
  698. /// <param name="aimSheetIndex">参照位置工作表索引，新工作表拷贝在该工作表后面</param>
  699. /// <param name="newSheetName"></param>
  700. public void CopyWorkSheet(int srcSheetIndex,int aimSheetIndex,string newSheetName)
  701. {
  702. if(srcSheetIndex > this.WorkSheetCount || aimSheetIndex > this.WorkSheetCount)
  703. {
  704. this.KillExcelProcess();
  705. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  706. }
  708. try
  709. {
  710. Worksheet srcSheet = (Worksheet)workBook.Sheets.get_Item(srcSheetIndex);
  711. Worksheet aimSheet = (Worksheet)workBook.Sheets.get_Item(aimSheetIndex);
  713. srcSheet.Copy(this.missing,aimSheet);
  715. //重命名
  716. workSheet = (Worksheet)aimSheet.Next; //获取新拷贝的工作表
  717. workSheet.Name = newSheetName;
  718. }
  719. catch(Exception e)
  720. {
  721. this.KillExcelProcess();
  722. throw e;
  723. }
  724. }
  727. /// <summary>
  728. /// 根据名称删除工作表
  729. /// </summary>
  730. /// <param name="sheetName"></param>
  731. public void DeleteWorkSheet(string sheetName)
  732. {
  733. try
  734. {
  735. Worksheet sheet = null;
  737. //找到名称位sheetName的工作表
  738. for(int i=1;i<=this.WorkSheetCount;i++)
  739. {
  740. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  742. if(workSheet.Name == sheetName)
  743. {
  744. sheet = workSheet;
  745. }
  746. }
  748. if(sheet != null)
  749. {
  750. sheet.Delete();
  751. }
  752. else
  753. {
  754. this.KillExcelProcess();
  755. throw new Exception("名称为"" + sheetName + ""的工作表不存在");
  756. }
  757. }
  758. catch(Exception e)
  759. {
  760. this.KillExcelProcess();
  761. throw e;
  762. }
  763. }
  765. /// <summary>
  766. /// 根据索引删除工作表
  767. /// </summary>
  768. /// <param name="sheetIndex"></param>
  769. public void DeleteWorkSheet(int sheetIndex)
  770. {
  771. if(sheetIndex > this.WorkSheetCount)
  772. {
  773. this.KillExcelProcess();
  774. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  775. }
  777. try
  778. {
  779. Worksheet sheet = null;
  780. sheet = (Worksheet)workBook.Sheets.get_Item(sheetIndex);
  782. sheet.Delete();
  783. }
  784. catch(Exception e)
  785. {
  786. this.KillExcelProcess();
  787. throw e;
  788. }
  789. }
  791. #endregion
  793. #region TextBox Methods
  794. /// <summary>
  795. /// 向指定文本框写入数据，对每个WorkSheet操作
  796. /// </summary>
  797. /// <param name="textboxName">文本框名称</param>
  798. /// <param name="text">要写入的文本</param>
  799. public void SetTextBox(string textboxName,string text)
  800. {
  801. for(int i=1;i<=this.WorkSheetCount;i++)
  802. {
  803. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  806. try
  807. {
  808. textBox = (TextBox)workSheet.TextBoxes(textboxName);
  809. textBox.Text = text;
  810. }
  811. catch
  812. {
  813. this.KillExcelProcess();
  814. throw new Exception("不存在ID为"" + textboxName + ""的文本框！");
  815. }
  816. }
  817. }
  819. /// <summary>
  820. /// 向指定文本框写入数据，对指定WorkSheet操作
  821. /// </summary>
  822. /// <param name="sheetIndex">工作表索引</param>
  823. /// <param name="textboxName">文本框名称</param>
  824. /// <param name="text">要写入的文本</param>
  825. public void SetTextBox(int sheetIndex,string textboxName,string text)
  826. {
  827. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  829. try
  830. {
  831. textBox = (TextBox)workSheet.TextBoxes(textboxName);
  832. textBox.Text = text;
  833. }
  834. catch
  835. {
  836. this.KillExcelProcess();
  837. throw new Exception("不存在ID为"" + textboxName + ""的文本框！");
  838. }
  839. }
  841. /// <summary>
  842. /// 向文本框写入数据，对每个WorkSheet操作
  843. /// </summary>
  844. /// <param name="ht">Hashtable的键值对保存文本框的ID和数据</param>
  845. public void SetTextBoxes(Hashtable ht)
  846. {
  847. if(ht.Count == 0) return;
  849. for(int i=1;i<=this.WorkSheetCount;i++)
  850. {
  851. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  853. foreach(DictionaryEntry dic in ht)
  854. {
  855. try
  856. {
  857. textBox = (TextBox)workSheet.TextBoxes(dic.Key);
  858. textBox.Text = dic.Value.ToString();
  859. }
  860. catch
  861. {
  862. this.KillExcelProcess();
  863. throw new Exception("不存在ID为"" + dic.Key.ToString() + ""的文本框！");
  864. }
  865. }
  866. }
  867. }
  869. /// <summary>
  870. /// 向文本框写入数据，对指定WorkSheet操作
  871. /// </summary>
  872. /// <param name="ht">Hashtable的键值对保存文本框的ID和数据</param>
  873. public void SetTextBoxes(int sheetIndex,Hashtable ht)
  874. {
  875. if(ht.Count == 0) return;
  877. if(sheetIndex > this.WorkSheetCount)
  878. {
  879. this.KillExcelProcess();
  880. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  881. }
  883. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  885. foreach(DictionaryEntry dic in ht)
  886. {
  887. try
  888. {
  889. textBox = (TextBox)workSheet.TextBoxes(dic.Key);
  890. textBox.Text = dic.Value.ToString();
  891. }
  892. catch
  893. {
  894. this.KillExcelProcess();
  895. throw new Exception("不存在ID为"" + dic.Key.ToString() + ""的文本框！");
  896. }
  897. }
  898. }
  899. #endregion
  901. #region Cell Methods
  902. /// <summary>
  903. /// 向单元格写入数据，对当前WorkSheet操作
  904. /// </summary>
  905. /// <param name="rowIndex">行索引</param>
  906. /// <param name="columnIndex">列索引</param>
  907. /// <param name="text">要写入的文本值</param>
  908. public void SetCells(int rowIndex,int columnIndex,string text)
  909. {
  910. try
  911. {
  912. workSheet.Cells[rowIndex,columnIndex] = text;
  913. }
  914. catch
  915. {
  916. this.KillExcelProcess();
  917. throw new Exception("向单元格[" + rowIndex + "," + columnIndex + "]写数据出错！");
  918. }
  919. }
  921. /// <summary>
  922. /// 向单元格写入数据，对指定WorkSheet操作
  923. /// </summary>
  924. /// <param name="sheetIndex">工作表索引</param>
  925. /// <param name="rowIndex">行索引</param>
  926. /// <param name="columnIndex">列索引</param>
  927. /// <param name="text">要写入的文本值</param>
  928. public void SetCells(int sheetIndex,int rowIndex,int columnIndex,string text)
  929. {
  930. try
  931. {
  932. this.ChangeCurrentWorkSheet(sheetIndex); //改变当前工作表为指定工作表
  933. workSheet.Cells[rowIndex,columnIndex] = text;
  934. }
  935. catch
  936. {
  937. this.KillExcelProcess();
  938. throw new Exception("向单元格[" + rowIndex + "," + columnIndex + "]写数据出错！");
  939. }
  940. }
  942. /// <summary>
  943. /// 向单元格写入数据，对每个WorkSheet操作
  944. /// </summary>
  945. /// <param name="ht">Hashtable的键值对保存单元格的位置索引（行索引和列索引用“,”隔开）和数据</param>
  946. public void SetCells(Hashtable ht)
  947. {
  948. int rowIndex;
  949. int columnIndex;
  950. string position;
  952. if(ht.Count == 0) return;
  954. for(int i=1;i<=this.WorkSheetCount;i++)
  955. {
  956. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  958. foreach(DictionaryEntry dic in ht)
  959. {
  960. try
  961. {
  962. position = dic.Key.ToString();
  963. rowIndex = Convert.ToInt32(position.Split(',')[0]);
  964. columnIndex = Convert.ToInt32(position.Split(',')[1]);
  966. workSheet.Cells[rowIndex,columnIndex] = dic.Value;
  967. }
  968. catch
  969. {
  970. this.KillExcelProcess();
  971. throw new Exception("向单元格[" + dic.Key + "]写数据出错！");
  972. }
  973. }
  974. }
  975. }
  977. /// <summary>
  978. /// 向单元格写入数据，对指定WorkSheet操作
  979. /// </summary>
  980. /// <param name="ht">Hashtable的键值对保存单元格的位置索引（行索引和列索引用“,”隔开）和数据</param>
  981. public void SetCells(int sheetIndex,Hashtable ht)
  982. {
  983. int rowIndex;
  984. int columnIndex;
  985. string position;
  987. if(sheetIndex > this.WorkSheetCount)
  988. {
  989. this.KillExcelProcess();
  990. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  991. }
  993. if(ht.Count == 0) return;
  995. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  997. foreach(DictionaryEntry dic in ht)
  998. {
  999. try
  1000. {
  1001. position = dic.Key.ToString();
  1002. rowIndex = Convert.ToInt32(position.Split(',')[0]);
  1003. columnIndex = Convert.ToInt32(position.Split(',')[1]);
  1005. workSheet.Cells[rowIndex,columnIndex] = dic.Value;
  1006. }
  1007. catch
  1008. {
  1009. this.KillExcelProcess();
  1010. throw new Exception("向单元格[" + dic.Key + "]写数据出错！");
  1011. }
  1012. }
  1013. }
  1015. /// <summary>
  1016. /// 设置单元格为可计算的
  1017. /// </summary>
  1018. /// <remarks>
  1019. /// 如果Excel的单元格格式设置为数字，日期或者其他类型时，需要设置这些单元格的FormulaR1C1属性，
  1020. /// 否则写到这些单元格的数据将不会按照预先设定的格式显示
  1021. /// </remarks>
  1022. /// <param name="arr">保存单元格的位置索引（行索引和列索引用“,”隔开）和数据</param>
  1023. public void SetCells(int sheetIndex,string[] arr)
  1024. {
  1025. int rowIndex;
  1026. int columnIndex;
  1027. string position;
  1029. if(sheetIndex > this.WorkSheetCount)
  1030. {
  1031. this.KillExcelProcess();
  1032. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1033. }
  1035. if(arr.Length == 0) return;
  1037. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  1039. for(int i=0;i<arr.Length;i++)
  1040. {
  1041. try
  1042. {
  1043. position = arr[i];
  1044. rowIndex = Convert.ToInt32(position.Split(',')[0]);
  1045. columnIndex = Convert.ToInt32(position.Split(',')[1]);
  1047. Range cell = (Range)workSheet.Cells[rowIndex,columnIndex];
  1048. cell.FormulaR1C1 = cell.Text;
  1049. }
  1050. catch
  1051. {
  1052. this.KillExcelProcess();
  1053. throw new Exception(string.Format("计算单元格{0}出错！",arr[i]));
  1054. }
  1055. }
  1056. }
  1058. /// <summary>
  1059. /// 向单元格写入数据，对指定WorkSheet操作
  1060. /// </summary>
  1061. /// <param name="ht">Hashtable的键值对保存单元格的位置索引（行索引和列索引用“,”隔开）和数据</param>
  1062. public void SetCells(string sheetName,Hashtable ht)
  1063. {
  1064. int rowIndex;
  1065. int columnIndex;
  1066. string position;
  1067. Worksheet sheet = null;
  1068. int sheetIndex = 0;
  1070. if(ht.Count == 0) return;
  1072. try
  1073. {
  1074. for(int i=1;i<=this.WorkSheetCount;i++)
  1075. {
  1076. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  1078. if(workSheet.Name == sheetName)
  1079. {
  1080. sheet = workSheet;
  1081. sheetIndex = workSheet.Index;
  1082. }
  1083. }
  1085. if(sheet != null)
  1086. {
  1087. foreach(DictionaryEntry dic in ht)
  1088. {
  1089. try
  1090. {
  1091. position = dic.Key.ToString();
  1092. rowIndex = Convert.ToInt32(position.Split(',')[0]);
  1093. columnIndex = Convert.ToInt32(position.Split(',')[1]);
  1095. sheet.Cells[rowIndex,columnIndex] = dic.Value;
  1096. }
  1097. catch
  1098. {
  1099. this.KillExcelProcess();
  1100. throw new Exception("向单元格[" + dic.Key + "]写数据出错！");
  1101. }
  1102. }
  1103. }
  1104. else
  1105. {
  1106. this.KillExcelProcess();
  1107. throw new Exception("名称为"" + sheetName + ""的工作表不存在");
  1108. }
  1109. }
  1110. catch(Exception e)
  1111. {
  1112. this.KillExcelProcess();
  1113. throw e;
  1114. }
  1115. }
  1118. /// <summary>
  1119. /// 合并单元格，并赋值，对每个WorkSheet操作
  1120. /// </summary>
  1121. /// <param name="beginRowIndex">开始行索引</param>
  1122. /// <param name="beginColumnIndex">开始列索引</param>
  1123. /// <param name="endRowIndex">结束行索引</param>
  1124. /// <param name="endColumnIndex">结束列索引</param>
  1125. /// <param name="text">合并后Range的值</param>
  1126. public void MergeCells(int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
  1127. {
  1128. for(int i=1;i<=this.WorkSheetCount;i++)
  1129. {
  1130. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  1131. range = workSheet.get_Range(workSheet.Cells[beginRowIndex,beginColumnIndex],workSheet.Cells[endRowIndex,endColumnIndex]);
  1133. range.ClearContents(); //先把Range内容清除，合并才不会出错
  1134. range.MergeCells = true;
  1135. range.Value2 = text;
  1136. range.HorizontalAlignment = XlHAlign.xlHAlignCenter;
  1137. range.VerticalAlignment = XlVAlign.xlVAlignCenter;
  1138. }
  1139. }
  1141. /// <summary>
  1142. /// 合并单元格，并赋值，对指定WorkSheet操作
  1143. /// </summary>
  1144. /// <param name="sheetIndex">WorkSheet索引</param>
  1145. /// <param name="beginRowIndex">开始行索引</param>
  1146. /// <param name="beginColumnIndex">开始列索引</param>
  1147. /// <param name="endRowIndex">结束行索引</param>
  1148. /// <param name="endColumnIndex">结束列索引</param>
  1149. /// <param name="text">合并后Range的值</param>
  1150. public void MergeCells(int sheetIndex,int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
  1151. {
  1152. if(sheetIndex > this.WorkSheetCount)
  1153. {
  1154. this.KillExcelProcess();
  1155. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1156. }
  1158. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  1159. range = workSheet.get_Range(workSheet.Cells[beginRowIndex,beginColumnIndex],workSheet.Cells[endRowIndex,endColumnIndex]);
  1161. range.ClearContents(); //先把Range内容清除，合并才不会出错
  1162. range.MergeCells = true;
  1163. range.Value2 = text;
  1164. range.HorizontalAlignment = XlHAlign.xlHAlignCenter;
  1165. range.VerticalAlignment = XlVAlign.xlVAlignCenter;
  1166. }
  1167. #endregion
  1169. #region Row Methods
  1170. /// <summary>
  1171. /// 将指定索引列的数据相同的行合并，对每个WorkSheet操作
  1172. /// </summary>
  1173. /// <param name="columnIndex">列索引</param>
  1174. /// <param name="beginRowIndex">开始行索引</param>
  1175. /// <param name="endRowIndex">结束行索引</param>
  1176. public void MergeRows(int columnIndex,int beginRowIndex,int endRowIndex)
  1177. {
  1178. if(endRowIndex - beginRowIndex < 1)
  1179. return;
  1181. for(int i=1;i<=this.WorkSheetCount;i++)
  1182. {
  1183. int beginIndex = beginRowIndex;
  1184. int count = 0;
  1185. string text1;
  1186. string text2;
  1187. workSheet = (Worksheet)workBook.Worksheets.get_Item(i);
  1189. for(int j=beginRowIndex;j<=endRowIndex;j++)
  1190. {
  1191. range = (Range)workSheet.Cells[j,columnIndex];
  1192. text1 = range.Text.ToString();
  1194. range = (Range)workSheet.Cells[j+1,columnIndex];
  1195. text2 = range.Text.ToString();
  1197. if(text1 == text2)
  1198. {
  1199. ++count;
  1200. }
  1201. else
  1202. {
  1203. if(count > 0)
  1204. {
  1205. this.MergeCells(workSheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
  1206. }
  1208. beginIndex = j + 1; //设置开始合并行索引
  1209. count = 0; //计数器清0
  1210. }
  1212. }
  1214. }
  1215. }
  1218. /// <summary>
  1219. /// 将指定索引列的数据相同的行合并，对指定WorkSheet操作
  1220. /// </summary>
  1221. /// <param name="sheetIndex">WorkSheet索引</param>
  1222. /// <param name="columnIndex">列索引</param>
  1223. /// <param name="beginRowIndex">开始行索引</param>
  1224. /// <param name="endRowIndex">结束行索引</param>
  1225. public void MergeRows(int sheetIndex,int columnIndex,int beginRowIndex,int endRowIndex)
  1226. {
  1227. if(sheetIndex > this.WorkSheetCount)
  1228. {
  1229. this.KillExcelProcess();
  1230. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1231. }
  1233. if(endRowIndex - beginRowIndex < 1)
  1234. return;
  1236. int beginIndex = beginRowIndex;
  1237. int count = 0;
  1238. string text1;
  1239. string text2;
  1240. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  1242. for(int j=beginRowIndex;j<=endRowIndex;j++)
  1243. {
  1244. range = (Range)workSheet.Cells[j,columnIndex];
  1245. text1 = range.Text.ToString();
  1247. range = (Range)workSheet.Cells[j+1,columnIndex];
  1248. text2 = range.Text.ToString();
  1250. if(text1 == text2)
  1251. {
  1252. ++count;
  1253. }
  1254. else
  1255. {
  1256. if(count > 0)
  1257. {
  1258. this.MergeCells(workSheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
  1259. }
  1261. beginIndex = j + 1; //设置开始合并行索引
  1262. count = 0; //计数器清0
  1263. }
  1265. }
  1267. }
  1270. /// <summary>
  1271. /// 插行（在指定行上面插入指定数量行）
  1272. /// </summary>
  1273. /// <param name="rowIndex"></param>
  1274. /// <param name="count"></param>
  1275. public void InsertRows(int rowIndex,int count)
  1276. {
  1277. try
  1278. {
  1279. for(int n=1;n<=this.WorkSheetCount;n++)
  1280. {
  1281. workSheet = (Worksheet)workBook.Worksheets[n];
  1282. range = (Range)workSheet.Rows[rowIndex,this.missing];
  1284. for(int i=0;i<count;i++)
  1285. {
  1286.                         range.Insert(XlDirection.xlDown,missing);
  1287.                         //range.InsertIndent(XlDirection.xlDown);
  1288. //range.Insert(XlDirection.xlDown);
  1289. }
  1290. }
  1291. }
  1292. catch(Exception e)
  1293. {
  1294. this.KillExcelProcess();
  1295. throw e;
  1296. }
  1297. }
  1299. /// <summary>
  1300. /// 插行（在指定WorkSheet指定行上面插入指定数量行）
  1301. /// </summary>
  1302. /// <param name="sheetIndex"></param>
  1303. /// <param name="rowIndex"></param>
  1304. /// <param name="count"></param>
  1305. public void InsertRows(int sheetIndex,int rowIndex,int count)
  1306. {
  1307. if(sheetIndex > this.WorkSheetCount)
  1308. {
  1309. this.KillExcelProcess();
  1310. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1311. }
  1313. try
  1314. {
  1315. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1316. range = (Range)workSheet.Rows[rowIndex,this.missing];
  1318. for(int i=0;i<count;i++)
  1319. {
  1320.                     range.Insert(XlDirection.xlDown, missing);
  1321.                     //range.InsertIndent(XlDirection.xlDown);
  1322. }
  1323. }
  1324. catch(Exception e)
  1325. {
  1326. this.KillExcelProcess();
  1327. throw e;
  1328. }
  1329. }
  1331. /// <summary>
  1332. /// 复制行（在指定行下面复制指定数量行）
  1333. /// </summary>
  1334. /// <param name="rowIndex"></param>
  1335. /// <param name="count"></param>
  1336. public void CopyRows(int rowIndex,int count)
  1337. {
  1338. try
  1339. {
  1340. for(int n=1;n<=this.WorkSheetCount;n++)
  1341. {
  1342. workSheet = (Worksheet)workBook.Worksheets[n];
  1343. range1 = (Range)workSheet.Rows[rowIndex,this.missing];
  1345. for(int i=1;i<=count;i++)
  1346. {
  1347. range2 = (Range)workSheet.Rows[rowIndex + i,this.missing];
  1348. range1.Copy(range2);
  1349. }
  1350. }
  1351. }
  1352. catch(Exception e)
  1353. {
  1354. this.KillExcelProcess();
  1355. throw e;
  1356. }
  1357. }
  1359. /// <summary>
  1360. /// 复制行（在指定WorkSheet指定行下面复制指定数量行）
  1361. /// </summary>
  1362. /// <param name="sheetIndex"></param>
  1363. /// <param name="rowIndex"></param>
  1364. /// <param name="count"></param>
  1365. public void CopyRows(int sheetIndex,int rowIndex,int count)
  1366. {
  1367. if(sheetIndex > this.WorkSheetCount)
  1368. {
  1369. this.KillExcelProcess();
  1370. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1371. }
  1373. try
  1374. {
  1375. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1376. range1 = (Range)workSheet.Rows[rowIndex,this.missing];
  1378. for(int i=1;i<=count;i++)
  1379. {
  1380. range2 = (Range)workSheet.Rows[rowIndex + i,this.missing];
  1381. range1.Copy(range2);
  1382. }
  1383. }
  1384. catch(Exception e)
  1385. {
  1386. this.KillExcelProcess();
  1387. throw e;
  1388. }
  1389. }
  1391. /// <summary>
  1392. /// 删除行
  1393. /// </summary>
  1394. /// <param name="rowIndex"></param>
  1395. /// <param name="count"></param>
  1396. public void DeleteRows(int rowIndex,int count)
  1397. {
  1398. try
  1399. {
  1400. for(int n=1;n<=this.WorkSheetCount;n++)
  1401. {
  1402. workSheet = (Worksheet)workBook.Worksheets[n];
  1403. range = (Range)workSheet.Rows[rowIndex,this.missing];
  1405. for(int i=0;i<count;i++)
  1406. {
  1407. range.Delete(XlDirection.xlDown);
  1408. }
  1409. }
  1410. }
  1411. catch(Exception e)
  1412. {
  1413. this.KillExcelProcess();
  1414. throw e;
  1415. }
  1416. }
  1418. /// <summary>
  1419. /// 删除行
  1420. /// </summary>
  1421. /// <param name="sheetIndex"></param>
  1422. /// <param name="rowIndex"></param>
  1423. /// <param name="count"></param>
  1424. public void DeleteRows(int sheetIndex,int rowIndex,int count)
  1425. {
  1426. if(sheetIndex > this.WorkSheetCount)
  1427. {
  1428. this.KillExcelProcess();
  1429. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1430. }
  1432. try
  1433. {
  1434. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1435. range = (Range)workSheet.Rows[rowIndex,this.missing];
  1437. for(int i=0;i<count;i++)
  1438. {
  1439. range.Delete(XlDirection.xlDown);
  1440. }
  1441. }
  1442. catch(Exception e)
  1443. {
  1444. this.KillExcelProcess();
  1445. throw e;
  1446. }
  1447. }
  1449. #endregion
  1451. #region Column Methods
  1453. /// <summary>
  1454. /// 插列（在指定列右边插入指定数量列）
  1455. /// </summary>
  1456. /// <param name="columnIndex"></param>
  1457. /// <param name="count"></param>
  1458. public void InsertColumns(int columnIndex,int count)
  1459. {
  1460. try
  1461. {
  1462. for(int n=1;n<=this.WorkSheetCount;n++)
  1463. {
  1464. workSheet = (Worksheet)workBook.Worksheets[n];
  1465. range = (Range)workSheet.Columns[this.missing,columnIndex];
  1467. for(int i=0;i<count;i++)
  1468. {
  1469. range.Insert(XlDirection.xlDown,missing);
  1470. }
  1471. }
  1472. }
  1473. catch(Exception e)
  1474. {
  1475. this.KillExcelProcess();
  1476. throw e;
  1477. }
  1478. }
  1480. /// <summary>
  1481. /// 插列（在指定WorkSheet指定列右边插入指定数量列）
  1482. /// </summary>
  1483. /// <param name="sheetIndex"></param>
  1484. /// <param name="columnIndex"></param>
  1485. /// <param name="count"></param>
  1486. public void InsertColumns(int sheetIndex,int columnIndex,int count)
  1487. {
  1488. if(sheetIndex > this.WorkSheetCount)
  1489. {
  1490. this.KillExcelProcess();
  1491. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1492. }
  1494. try
  1495. {
  1496. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1497. range = (Range)workSheet.Columns[this.missing,columnIndex];
  1499. for(int i=0;i<count;i++)
  1500. {
  1501. range.Insert(XlDirection.xlDown,missing);
  1502. }
  1503. }
  1504. catch(Exception e)
  1505. {
  1506. this.KillExcelProcess();
  1507. throw e;
  1508. }
  1509. }
  1511. /// <summary>
  1512. /// 复制列（在指定列右边复制指定数量列）
  1513. /// </summary>
  1514. /// <param name="columnIndex"></param>
  1515. /// <param name="count"></param>
  1516. public void CopyColumns(int columnIndex,int count)
  1517. {
  1518. try
  1519. {
  1520. for(int n=1;n<=this.WorkSheetCount;n++)
  1521. {
  1522. workSheet = (Worksheet)workBook.Worksheets[n];
  1523. // range1 = (Range)workSheet.Columns[columnIndex,this.missing];
  1524. range1 = (Range)workSheet.get_Range(this.IntToLetter(columnIndex)+"1",this.IntToLetter(columnIndex)+"10000");
  1526. for(int i=1;i<=count;i++)
  1527. {
  1528. // range2 = (Range)workSheet.Columns[this.missing,columnIndex + i];
  1529. range2 = (Range)workSheet.get_Range(this.IntToLetter(columnIndex+i)+"1",this.IntToLetter(columnIndex+i)+"10000");
  1530. range1.Copy(range2);
  1531. }
  1532. }
  1533. }
  1534. catch(Exception e)
  1535. {
  1536. this.KillExcelProcess();
  1537. throw e;
  1538. }
  1539. }
  1541. /// <summary>
  1542. /// 复制列（在指定WorkSheet指定列右边复制指定数量列）
  1543. /// </summary>
  1544. /// <param name="sheetIndex"></param>
  1545. /// <param name="columnIndex"></param>
  1546. /// <param name="count"></param>
  1547. public void CopyColumns(int sheetIndex,int columnIndex,int count)
  1548. {
  1549. if(sheetIndex > this.WorkSheetCount)
  1550. {
  1551. this.KillExcelProcess();
  1552. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1553. }
  1555. try
  1556. {
  1557. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1558. // range1 = (Range)workSheet.Columns[Type.Missing,columnIndex];
  1559. range1 = (Range)workSheet.get_Range(this.IntToLetter(columnIndex)+"1",this.IntToLetter(columnIndex)+"10000");
  1561. for(int i=1;i<=count;i++)
  1562. {
  1563. // range2 = (Range)workSheet.Columns[Type.Missing,columnIndex + i];
  1564. range2 = (Range)workSheet.get_Range(this.IntToLetter(columnIndex+i)+"1",this.IntToLetter(columnIndex+i)+"10000");
  1565. range1.Copy(range2);
  1566. }
  1567. }
  1568. catch(Exception e)
  1569. {
  1570. this.KillExcelProcess();
  1571. throw e;
  1572. }
  1573. }
  1575. /// <summary>
  1576. /// 删除列
  1577. /// </summary>
  1578. /// <param name="columnIndex"></param>
  1579. /// <param name="count"></param>
  1580. public void DeleteColumns(int columnIndex,int count)
  1581. {
  1582. try
  1583. {
  1584. for(int n=1;n<=this.WorkSheetCount;n++)
  1585. {
  1586. workSheet = (Worksheet)workBook.Worksheets[n];
  1587. range = (Range)workSheet.Columns[this.missing,columnIndex];
  1589. for(int i=0;i<count;i++)
  1590. {
  1591. range.Delete(XlDirection.xlDown);
  1592. }
  1593. }
  1594. }
  1595. catch(Exception e)
  1596. {
  1597. this.KillExcelProcess();
  1598. throw e;
  1599. }
  1600. }
  1602. /// <summary>
  1603. /// 删除列
  1604. /// </summary>
  1605. /// <param name="sheetIndex"></param>
  1606. /// <param name="columnIndex"></param>
  1607. /// <param name="count"></param>
  1608. public void DeleteColumns(int sheetIndex,int columnIndex,int count)
  1609. {
  1610. if(sheetIndex > this.WorkSheetCount)
  1611. {
  1612. this.KillExcelProcess();
  1613. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1614. }
  1616. try
  1617. {
  1618. workSheet = (Worksheet)workBook.Worksheets[sheetIndex];
  1619. range = (Range)workSheet.Columns[this.missing,columnIndex];
  1621. for(int i=0;i<count;i++)
  1622. {
  1623. range.Delete(XlDirection.xlDown);
  1624. }
  1625. }
  1626. catch(Exception e)
  1627. {
  1628. this.KillExcelProcess();
  1629. throw e;
  1630. }
  1631. }
  1633. #endregion
  1635. #region Range Methods
  1637. /// <summary>
  1638. /// 将指定范围区域拷贝到目标区域
  1639. /// </summary>
  1640. /// <param name="sheetIndex">WorkSheet索引</param>
  1641. /// <param name="startCell">要拷贝区域的开始Cell位置（比如：A10）</param>
  1642. /// <param name="endCell">要拷贝区域的结束Cell位置（比如：F20）</param>
  1643. /// <param name="targetCell">目标区域的开始Cell位置（比如：H10）</param>
  1644. public void RangeCopy(int sheetIndex,string startCell,string endCell,string targetCell)
  1645. {
  1646. if(sheetIndex > this.WorkSheetCount)
  1647. {
  1648. this.KillExcelProcess();
  1649. throw new Exception("索引超出范围，WorkSheet索引不能大于WorkSheet数量！");
  1650. }
  1652. try
  1653. {
  1654. workSheet = (Worksheet)workBook.Worksheets.get_Item(sheetIndex);
  1655. range1 = workSheet.get_Range(startCell,endCell);
  1656. range2 = workSheet.get_Range(targetCell,this.missing);
  1658. range1.Copy(range2);
  1659. }
  1660. catch(Exception e)
  1661. {
  1662. this.KillExcelProcess();
  1663. throw e;
  1664. }
  1665. }
  1667. /// <summary>
  1668. /// 将指定范围区域拷贝到目标区域
  1669. /// </summary>
  1670. /// <param name="sheetName">WorkSheet名称</param>
  1671. /// <param name="startCell">要拷贝区域的开始Cell位置（比如：A10）</param>
  1672. /// <param name="endCell">要拷贝区域的结束Cell位置（比如：F20）</param>
  1673. /// <param name="targetCell">目标区域的开始Cell位置（比如：H10）</param>
  1674. public void RangeCopy(string sheetName,string startCell,string endCell,string targetCell)
  1675. {
  1676. try
  1677. {
  1678. Worksheet sheet = null;
  1680. for(int i=1;i<=this.WorkSheetCount;i++)
  1681. {
  1682. workSheet = (Worksheet)workBook.Sheets.get_Item(i);
  1684. if(workSheet.Name == sheetName)
  1685. {
  1686. sheet = workSheet;
  1687. }
  1688. }
  1690. if(sheet != null)
  1691. {
  1692. for(int i=sheetCount;i>=1;i--)
  1693. {
  1694. range1 = sheet.get_Range(startCell,endCell);
  1695. range2 = sheet.get_Range(targetCell,this.missing);
  1697. range1.Copy(range2);
  1698. }
  1699. }
  1700. else
  1701. {
  1702. this.KillExcelProcess();
  1703. throw new Exception("名称为"" + sheetName + ""的工作表不存在");
  1704. }
  1705. }
  1706. catch(Exception e)
  1707. {
  1708. this.KillExcelProcess();
  1709. throw e;
  1710. }
  1711. }
  1713. /// <summary>
  1714. /// 自动填充
  1715. /// </summary>
  1716. public void RangAutoFill()
  1717. {
  1718. Range rng = workSheet.get_Range("B4", Type.Missing); 
  1719. rng.Value2 = "星期一 ";
  1720. rng.AutoFill(workSheet.get_Range("B4","B9"),
  1721. XlAutoFillType.xlFillWeekdays); 
  1723. rng = workSheet.get_Range("C4", Type.Missing); 
  1724. rng.Value2  = "一月";
  1725. rng.AutoFill(workSheet.get_Range("C4","C9"),
  1726. XlAutoFillType.xlFillMonths); 
  1728. rng = workSheet.get_Range("D4",Type.Missing);
  1729. rng.Value2 = "1";
  1730. rng.AutoFill(workSheet.get_Range("D4","D9"), 
  1731. XlAutoFillType.xlFillSeries);
  1733. rng = workSheet.get_Range("E4",Type.Missing); 
  1734. rng.Value2 = "3";
  1735. rng = workSheet.get_Range("E5",Type.Missing);
  1736. rng.Value2 = "6";
  1737. rng = workSheet.get_Range("E4","E5");
  1738. rng.AutoFill(workSheet.get_Range("E4","E9"), 
  1739. XlAutoFillType.xlFillSeries);
  1741. }
  1743. /// <summary>
  1744. /// 应用样式
  1745. /// </summary>
  1746. public void ApplyStyle()
  1747. {
  1748. object missingValue = Type.Missing;
  1749. Range rng = workSheet.get_Range("B3","L23");
  1750. Style style;
  1752. try
  1753. {
  1754. style = workBook.Styles["NewStyle"];
  1755. }
  1756. // Style doesn't exist yet.
  1757. catch
  1758. {
  1759. style = workBook.Styles.Add("NewStyle", missingValue);
  1760. style.Font.Name = "Verdana";
  1761. style.Font.Size = 12;
  1762. style.Font.Color = 255;
  1763. style.Interior.Color = (200 << 16) | (200 << 8) | 200;
  1764. style.Interior.Pattern = XlPattern.xlPatternSolid;
  1765. }
  1767. rng.Value2 = "'Style Test";
  1768. rng.Style = "NewStyle";
  1769. rng.Columns.AutoFit();
  1770. }
  1772. #endregion
  1774.         #region EtongExcel Kit
  1775.         /// <summary>
  1776. /// 将Excel列的字母索引值转换成整数索引值
  1777. /// </summary>
  1778. /// <param name="letter"></param>
  1779. /// <returns></returns>
  1780. public int LetterToInt(string letter)
  1781. {
  1782. int n = 0;
  1784. if(letter.Trim().Length == 0)
  1785. throw new Exception("不接受空字符串！");
  1787. if(letter.Length >= 2)
  1788. {
  1789. char c1 = letter.ToCharArray(0,2)[0];
  1790. char c2 = letter.ToCharArray(0,2)[1];
  1792. if(!char.IsLetter(c1) || !char.IsLetter(c2))
  1793. {
  1794. throw new Exception("格式不正确，必须是字母！");
  1795. }
  1797. c1 = char.ToUpper(c1);
  1798. c2 = char.ToUpper(c2);
  1800. int i = Convert.ToInt32(c1) - 64;
  1801. int j = Convert.ToInt32(c2) - 64;
  1803. n = i * 26 + j;
  1804. }
  1806. if(letter.Length == 1)
  1807. {
  1808. char c1 = letter.ToCharArray()[0];
  1810. if(!char.IsLetter(c1))
  1811. {
  1812. throw new Exception("格式不正确，必须是字母！");
  1813. }
  1815. c1 = char.ToUpper(c1);
  1817. n = Convert.ToInt32(c1) - 64;
  1818. }
  1820. if(n > 256)
  1821. throw new Exception("索引超出范围，Excel的列索引不能超过256！");
  1823. return n;
  1824. }
  1826. /// <summary>
  1827. /// 将Excel列的整数索引值转换为字符索引值
  1828. /// </summary>
  1829. /// <param name="n"></param>
  1830. /// <returns></returns>
  1831. public string IntToLetter(int n)
  1832. {
  1833. if(n > 256)
  1834. throw new Exception("索引超出范围，Excel的列索引不能超过256！");
  1836. int i = Convert.ToInt32(n / 26);
  1837. int j = n % 26;
  1839. char c1 = Convert.ToChar( i + 64 );
  1840. char c2 = Convert.ToChar( j + 64 );
  1842. if(n > 26)
  1843. return c1.ToString() + c2.ToString();
  1844. else if(n == 26)
  1845. return "Z";
  1846. else
  1847. return c2.ToString();
  1848. }
  1850. #endregion
  1852. #region Output File(注意：如果目标文件已存在的话会出错)
  1853. /// <summary>
  1854. /// 输出Excel文件并退出
  1855. /// </summary>
  1856. public void OutputExcelFile()
  1857. {
  1858. if(this.outputFile == null)
  1859. throw new Exception("没有指定输出文件路径！");
  1861. try
  1862. {
  1863.                 workBook.SaveAs(outputFile, missing, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1864. //workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1865. }
  1866. catch(Exception e)
  1867. {
  1868. throw e;
  1869. }
  1870. finally
  1871. {
  1872. this.Dispose();
  1873. }
  1874. }
  1876. /// <summary>
  1877. /// 输出指定格式的文件（支持格式：HTML，CSV，TEXT，EXCEL）
  1878. /// </summary>
  1879. /// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
  1880. public void OutputFile(string format)
  1881. {
  1882. if(this.outputFile == null)
  1883. throw new Exception("没有指定输出文件路径！");
  1885. try
  1886. {
  1887. switch(format)
  1888. {
  1889. case "HTML":
  1890. {
  1891.                         workBook.SaveAs(outputFile,XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1892. //workBook.SaveAs(outputFile,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1893. break;
  1894. }
  1895. case "CSV":
  1896. {
  1897.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1898. //workBook.SaveAs(outputFile,XlFileFormat.xlCSV,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1899. break;
  1900. }
  1901. case "TEXT":
  1902. {
  1903.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1904. //workBook.SaveAs(outputFile,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1905. break;
  1906. }
  1907. // case "XML":
  1908. // {
  1909. // workBook.SaveAs(outputFile,XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
  1910. // Type.Missing, Type.Missing, XlSaveAsAccessMode.xlNoChange,
  1911. // Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
  1912. // break;
  1913. //
  1914. // }
  1915. default:
  1916. {
  1917.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1918. //workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1919. break;
  1920. }
  1921. }
  1922. }
  1923. catch(Exception e)
  1924. {
  1925. throw e;
  1926. }
  1927. finally
  1928. {
  1929. this.Dispose();
  1930. }
  1931. }
  1933. /// <summary>
  1934. /// 保存文件
  1935. /// </summary>
  1936. public void SaveFile()
  1937. {
  1938. try
  1939. {
  1940. workBook.Save();
  1941. }
  1942. catch(Exception e)
  1943. {
  1944. throw e;
  1945. }
  1946. finally
  1947. {
  1948. this.Dispose();
  1949. }
  1950. }
  1952. /// <summary>
  1953. /// 另存文件
  1954. /// </summary>
  1955. public void SaveAsFile()
  1956. {
  1957. if(this.outputFile == null)
  1958. throw new Exception("没有指定输出文件路径！");
  1960. try
  1961. {
  1962.                 workBook.SaveAs(outputFile, missing, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1963. //workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1964. }
  1965. catch(Exception e)
  1966. {
  1967. throw e;
  1968. }
  1969. finally
  1970. {
  1971. this.Dispose();
  1972. }
  1973. }
  1975. /// <summary>
  1976. /// 将Excel文件另存为指定格式
  1977. /// </summary>
  1978. /// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
  1979. public void SaveAsFile(string format)
  1980. {
  1981. if(this.outputFile == null)
  1982. throw new Exception("没有指定输出文件路径！");
  1984. try
  1985. {
  1986. switch(format)
  1987. {
  1988. case "HTML":
  1989. {
  1990.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1991. //workBook.SaveAs(outputFile,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1992. break;
  1993. }
  1994. case "CSV":
  1995. {
  1996.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  1997. //workBook.SaveAs(outputFile,XlFileFormat.xlCSV,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  1998. break;
  1999. }
  2000. case "TEXT":
  2001. {
  2002.                         workBook.SaveAs(outputFile, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2003. //workBook.SaveAs(outputFile,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2004. break;
  2005. }
  2006. // case "XML":
  2007. // {
  2008. // workBook.SaveAs(outputFile,XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
  2009. // Type.Missing, Type.Missing, XlSaveAsAccessMode.xlNoChange,
  2010. // Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
  2011. // break;
  2012. // }
  2013. default:
  2014. {
  2015.                         workBook.SaveAs(outputFile, missing , missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2016. //workBook.SaveAs(outputFile,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2017. break;
  2018. }
  2019. }
  2020. }
  2021. catch(Exception e)
  2022. {
  2023. throw e;
  2024. }
  2025. finally
  2026. {
  2027. this.Dispose();
  2028. }
  2029. }
  2031. /// <summary>
  2032. /// 另存文件
  2033. /// </summary>
  2034. /// <param name="fileName">文件名</param>
  2035. public void SaveFile(string fileName)
  2036. {
  2037. try
  2038. {
  2039.                 workBook.SaveAs(fileName, missing, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2040. //workBook.SaveAs(fileName,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2041. }
  2042. catch(Exception e)
  2043. {
  2044. throw e;
  2045. }
  2046. finally
  2047. {
  2048. this.Dispose();
  2049. }
  2050. }
  2052. /// <summary>
  2053. /// 将Excel文件另存为指定格式
  2054. /// </summary>
  2055. /// <param name="fileName">文件名</param>
  2056. /// <param name="format">HTML，CSV，TEXT，EXCEL，XML</param>
  2057. public void SaveAsFile(string fileName,string format)
  2058. {
  2059. try
  2060. {
  2061. switch(format)
  2062. {
  2063. case "HTML":
  2064. {
  2065.                         workBook.SaveAs(fileName, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2066. //workBook.SaveAs(fileName,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2067. break;
  2068. }
  2069. case "CSV":
  2070. {
  2071.                         workBook.SaveAs(fileName, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2072. //workBook.SaveAs(fileName,XlFileFormat.xlCSV,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2073. break;
  2074. }
  2075. case "TEXT":
  2076. {
  2077.                         workBook.SaveAs(fileName, XlFileFormat.xlHtml, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2078. //workBook.SaveAs(fileName,XlFileFormat.xlHtml,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2079. break;
  2080. }
  2081. // case "XML":
  2082. // {
  2083. // workBook.SaveAs(fileName,XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,
  2084. // Type.Missing, Type.Missing, XlSaveAsAccessMode.xlNoChange,
  2085. // Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
  2086. // break;
  2087. // }
  2088. default:
  2089. {
  2090.                         workBook.SaveAs(fileName, missing, missing, missing, missing, missing, XlSaveAsAccessMode.xlExclusive, missing, missing, missing, missing, missing);
  2091. //workBook.SaveAs(fileName,missing,missing,missing,missing,missing,XlSaveAsAccessMode.xlExclusive,missing,missing,missing,missing);
  2092. break;
  2093. }
  2094. }
  2095. }
  2096. catch(Exception e)
  2097. {
  2098. throw e;
  2099. }
  2100. finally
  2101. {
  2102. this.Dispose();
  2103. }
  2104. }
  2105. #endregion
  2107. #endregion
  2109. #region 私有方法
  2111. /// <summary>
  2112. /// 合并单元格，并赋值，对指定WorkSheet操作
  2113. /// </summary>
  2114. /// <param name="beginRowIndex">开始行索引</param>
  2115. /// <param name="beginColumnIndex">开始列索引</param>
  2116. /// <param name="endRowIndex">结束行索引</param>
  2117. /// <param name="endColumnIndex">结束列索引</param>
  2118. /// <param name="text">合并后Range的值</param>
  2119. private void MergeCells(Worksheet sheet,int beginRowIndex,int beginColumnIndex,int endRowIndex,int endColumnIndex,string text)
  2120. {
  2121. if(sheet == null)
  2122. return;
  2124. range = sheet.get_Range(sheet.Cells[beginRowIndex,beginColumnIndex],sheet.Cells[endRowIndex,endColumnIndex]);
  2126. range.ClearContents(); //先把Range内容清除，合并才不会出错
  2127. range.MergeCells = true;
  2128. range.Value2 = text;
  2129. range.HorizontalAlignment = XlHAlign.xlHAlignCenter;
  2130. range.VerticalAlignment = XlVAlign.xlVAlignCenter;
  2131. }
  2133. /// <summary>
  2134. /// 将指定索引列的数据相同的行合并，对指定WorkSheet操作
  2135. /// </summary>
  2136. /// <param name="columnIndex">要合并的列索引</param>
  2137. /// <param name="beginRowIndex">合并开始行索引</param>
  2138. /// <param name="rows">要合并的行数</param>
  2139. private void MergeRows(Worksheet sheet,int columnIndex,int beginRowIndex,int rows)
  2140. {
  2141. int beginIndex = beginRowIndex;
  2142. int count = 0;
  2143. string text1;
  2144. string text2;
  2146. if(sheet == null)
  2147. return;
  2149. for(int j=beginRowIndex;j<beginRowIndex+rows;j++)
  2150. {
  2151. range1 = (Range)sheet.Cells[j,columnIndex];
  2152. range2 = (Range)sheet.Cells[j+1,columnIndex];
  2153. text1 = range1.Text.ToString();
  2154. text2 = range2.Text.ToString();
  2156. if(text1 == text2)
  2157. {
  2158. ++count;
  2159. }
  2160. else
  2161. {
  2162. if(count > 0)
  2163. {
  2164. this.MergeCells(sheet,beginIndex,columnIndex,beginIndex+count,columnIndex,text1);
  2165. }
  2167. beginIndex = j + 1; //设置开始合并行索引
  2168. count = 0; //计数器清0
  2169. }
  2171. }
  2173. }
  2176. /// <summary>
  2177. /// 计算WorkSheet数量
  2178. /// </summary>
  2179. /// <param name="rowCount">记录总行数</param>
  2180. /// <param name="rows">每WorkSheet行数</param>
  2181. public int GetSheetCount(int rowCount,int rows)
  2182. {
  2183. int n = rowCount % rows; //余数
  2185. if(n == 0)
  2186. return rowCount / rows;
  2187. else
  2188. return Convert.ToInt32(rowCount / rows) + 1;
  2189. }
  2191. /// <summary>
  2192. /// 结束Excel进程
  2193. /// </summary>
  2194. public void KillExcelProcess()
  2195. {
  2196. Process[] myProcesses;
  2197. DateTime startTime;
  2198. myProcesses = Process.GetProcessesByName("Excel");
  2200. //得不到Excel进程ID，暂时只能判断进程启动时间
  2201. foreach(Process myProcess in myProcesses)
  2202. {
  2203. startTime = myProcess.StartTime;
  2205.                 if(startTime > beforeTime && startTime < afterTime)
  2206.                 {
  2207. myProcess.Kill();
  2208.                 }
  2209. }
  2210. }
  2213. private void Dispose()
  2214. {
  2215. workBook.Close(null,null,null);
  2216.             app.Workbooks.Close();
  2217. app.Quit();
  2219. if(range != null)
  2220. {
  2221. System.Runtime.InteropServices.Marshal.ReleaseComObject(range);
  2222. range = null;
  2223. }
  2224. if(range1 != null)
  2225. {
  2226. System.Runtime.InteropServices.Marshal.ReleaseComObject(range1);
  2227. range1 = null;
  2228. }
  2229. if(range2 != null)
  2230. {
  2231. System.Runtime.InteropServices.Marshal.ReleaseComObject(range2);
  2232. range2 = null;
  2233. }
  2234. if(textBox != null)
  2235. {
  2236. System.Runtime.InteropServices.Marshal.ReleaseComObject(textBox);
  2237. textBox = null;
  2238. }
  2239. if(workSheet != null)
  2240. {
  2241. System.Runtime.InteropServices.Marshal.ReleaseComObject(workSheet);
  2242. workSheet = null;
  2243. }
  2244. if(workBook != null)
  2245. {
  2246. System.Runtime.InteropServices.Marshal.ReleaseComObject(workBook);
  2247. workBook = null;
  2248. }
  2249. if(app != null)
  2250. {
  2251. System.Runtime.InteropServices.Marshal.ReleaseComObject(app);
  2252. app = null;
  2253. }
  2255. GC.Collect();
  2257. this.KillExcelProcess();
  2259. }//end Dispose
  2260. #endregion
  2262.         #region Excel数组文件 写入合并
  2263.         /// <summary>
  2264.         /// 合并Excel文件
  2265.         /// </summary>
  2266.         /// <param name="FileName">源文件名数组</param>
  2267.         /// <param name="startrow">起始行</param>
  2268.         /// <param name="totalcols">终止列</param>
  2269.         public void RangeCellSet(ArrayList FileName,int startrow,int totalcols)
  2270.         {
  2271.             
  2272.             int rows = 1 + startrow ;
  2273.             //int cols = 1;
  2275.             for (int k = 0; k < FileName.Count; k++)
  2276.             {
  2277.                 if (!File.Exists(FileName[k].ToString()))
  2278.                     throw new Exception("指定路径的Excel文件不存在！");
  2280.                 DateTime beforeTime1; //Excel启动之前时间
  2281.         DateTime afterTime1; //Excel启动之后时间
  2283.                 //创建一个Application对象并使其可见
  2284.                 beforeTime1 = DateTime.Now;
  2285.                 Application app1 = new ApplicationClass();
  2286.                 //app = new ApplicationClass();
  2287.                 //app.Visible = true;
  2288.                 afterTime1 = DateTime.Now;
  2289.                 //打开一个WorkBook
  2290.                 Workbook workbook1;
  2292.                 workbook1 = app1.Workbooks.Open(FileName[k].ToString(),
  2293.                     Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  2294.                     Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  2295.                     Type.Missing, Type.Missing, Type.Missing, Type.Missing,
  2296.                     Type.Missing, Type.Missing);
  2297.                 
  2298.                 //得到WorkSheet对象
  2299.                 Worksheet worksheet1;
  2300.                 worksheet1 = (Worksheet)workbook1.Sheets.get_Item(1);
  2302.                 int ibreak = 0;
  2303.                 int inull = 0;
  2305.                 for (int i = startrow; i < worksheet1.Rows.Count; i++)
  2306.                 {
  2308.                     for (int j = 0; j < totalcols; j++)
  2309.                     {
  2310.                         range1 = (Range)worksheet1.Cells[i + 1, j + 1];
  2311.                         if (range1.Value2 == null && inull == 2*totalcols)
  2312.                         {
  2313.                             rows--;
  2314.                             ibreak = -1;
  2315.                             break;
  2316.                         }
  2317.                         if (range1.Value2 != null)
  2318.                         {
  2319.                             inull = 0;
  2320.                             this.SetCells(rows , j+1 , range1.Value2.ToString());
  2321.                         }
  2322.                         else inull++;
  2323.                     }
  2324.                     if (ibreak == -1) break;
  2325.                     rows++;
  2326.                 }
  2327.                 workbook1.Close(null, null, null);
  2328.                 app1.Workbooks.Close();
  2329.                 app1.Quit();
  2331.                 Process[] myProcesses;
  2332.                 DateTime startTime;
  2333.                 myProcesses = Process.GetProcessesByName("Excel");
  2334.                 
  2335.                 //得不到Excel进程ID，暂时只能判断进程启动时间
  2336.                 int m = 0;
  2337.                 foreach (Process myProcess in myProcesses)
  2338.                 {
  2339.                     startTime = myProcess.StartTime;
  2340.                     //string id = myProcesses.GetValue(m).ToString();
  2341.                     
  2342.                     m++;
  2343.                     if (startTime > beforeTime1 && startTime < afterTime1)
  2344.                     {
  2345.                         myProcess.Kill();
  2346.                     }
  2347.                 }
  2348.                 
  2349.                 //this.KillExcelProcess();
  2350.             }
  2351.             //this.SaveAsFile();
  2352.         }
  2353.         #endregion
  2355.     }//end class
  2356. }//end namespace