1.  public class NPOIHelper
  2.     {
  3.         public static void WriteDataToExceel(string fileName, DataSet ds)
  4.         {
  5.             if (File.Exists(fileName))
  6.                 throw new Exception("File is Exists!");
  7.             using (FileStream stream = new FileStream(fileName, FileMode.Create))
  8.             {
  9.                 try
  10.                 {
  11.                     IWorkbook workbook = ReadToWorkBook(ds, fileName);
  12.                     workbook.Write(stream);
  13.                 }
  14.                 catch (Exception exception)
  15.                 {
  16.                     throw exception;
  17.                 }
  18.             }
  19.         }
  20.  
  21.         public static void WriteDataToExceel(string fileName, DataTable dt)
  22.         {
  23.             if (File.Exists(fileName))
  24.                 throw new Exception("File is Exists!");
  25.             using (FileStream stream = new FileStream(fileName, FileMode.Create))
  26.             {
  27.                 try
  28.                 {
  29.                     IWorkbook workbook = ReadToWorkBook(dt, fileName);
  30.                     workbook.Write(stream);
  31.                 }
  32.                 catch (Exception exception)
  33.                 {
  34.                     throw exception;
  35.                 }
  36.             }
  37.         }
  38.  
  39.         public static MemoryStream WriteDataToExcel(DataSet ds, string Extension = ".xls")
  40.         {
  41.             MemoryStream memoryStream = new MemoryStream();
  42.             try
  43.             {
  44.                 IWorkbook workbook = ReadToWorkBook(ds, Extension);
  45.                 workbook.Write(memoryStream);
  46.  
  47.                 workbook = null;
  48.             }
  49.             catch (Exception exception)
  50.             {
  51.                 throw exception;
  52.             }
  53.             return memoryStream;
  54.         }
  55.  
  56.         private static IWorkbook ReadToWorkBook(DataSet ds, string Extension)
  57.         {
  58.             IWorkbook workbook = null;
  59.             if (Extension.ToLower().EndsWith(".xls"))
  60.                 workbook = new HSSFWorkbook();
  61.             else
  62.                 workbook = new XSSFWorkbook();
  63.             foreach (DataTable table in ds.Tables)
  64.             {
  65.                 ISheet sheet = workbook.CreateSheet(table.TableName);
  66.                 IRow headerRow = sheet.CreateRow(0);
  67.                 foreach (DataColumn column in table.Columns)
  68.                 {
  69.                     headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
  70.                 }
  71.                 int rowIndex = 1;
  72.                 foreach (DataRow row in table.Rows)
  73.                 {
  74.                     IRow dataRow = sheet.CreateRow(rowIndex);
  75.                     DateTime temp = DateTime.Now;
  76.                     foreach (DataColumn column in table.Columns)
  77.                     {
  78.                         if (DateTime.TryParse(row[column].ToString(),out temp))
  79.                         {
  80.                             dataRow.CreateCell(column.Ordinal).SetCellValue(temp.ToString("yyyy-MM-dd"));
  81.                         }
  82.                         else
  83.                         {
  84.                             dataRow.CreateCell(column.Ordinal).SetCellValue(row[column].ToString());
  85.                         }
  86.                         sheet.SetColumnWidth(column.Ordinal, 4000);
  87.                     }
  88.                     rowIndex++;
  89.                 }
  90.                 sheet = null;
  91.                 headerRow = null;
  92.             }
  93.  
  94.             return workbook;
  95.         }
  96.  
  97.         private static IWorkbook ReadToWorkBook(DataTable dt, string Extension)
  98.         {
  99.             IWorkbook workbook = null;
  100.             if (Extension.ToLower().EndsWith(".xls"))
  101.                 workbook = new HSSFWorkbook();
  102.             else
  103.                 workbook = new XSSFWorkbook();
  104.             //foreach (DataTable table in ds.Tables)
  105.             //{
  106.                 ISheet sheet = workbook.CreateSheet(dt.TableName);
  107.                 IRow headerRow = sheet.CreateRow(0);
  108.                 foreach (DataColumn column in dt.Columns)
  109.                 {
  110.                     headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
  111.                 }
  112.                 int rowIndex = 1;
  113.                 foreach (DataRow row in dt.Rows)
  114.                 {
  115.                     IRow dataRow = sheet.CreateRow(rowIndex);
  116.                     foreach (DataColumn column in dt.Columns)
  117.                     {
  118.                         dataRow.CreateCell(column.Ordinal).SetCellValue(row[column].ToString());
  119.                     }
  120.  
  121.                     rowIndex++;
  122.                 }
  123.                 sheet = null;
  124.                 headerRow = null;
  125.           //  }
  126.  
  127.             return workbook;
  128.         }
  129.  
  130.         public static DataSet ExcelToDataSet(string excelPath)
  131.         {
  132.             return ExcelToDataSet(excelPath, true);
  133.         }
  134.         public static DataSet ExcelToDataSet(string excelPath, bool firstRowAsHeader)
  135.         {
  136.             int sheetCount;
  137.             try
  138.             {
  139.                 return ExcelToDataSet(excelPath, firstRowAsHeader, out sheetCount);
  140.             }
  141.             catch
  142.             {
  143.                 return ExcelToDataSet(excelPath, firstRowAsHeader, out sheetCount, true);
  144.             }
  145.         }
  146.  
  147.         public static DataSet ExcelToDataSet(string excelPath, bool firstRowAsHeader, out int sheetCount, bool isXlsx = false)
  148.         {
  149.             using (DataSet ds = new DataSet())
  150.             {
  151.                 using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
  152.                 {
  153.                     IWorkbook workbook;
  154.                     IFormulaEvaluator evaluator;
  155.                     GetWorkBook(excelPath, fileStream, out workbook, out evaluator, isXlsx);
  156.                     sheetCount = workbook.NumberOfSheets;
  157.                     for (int i = 0; i < sheetCount; ++i)
  158.                     {
  159.                         DataTable dt = ExcelToDataTable(workbook.GetSheetAt(i), evaluator, firstRowAsHeader);
  160.                         ds.Tables.Add(dt);
  161.                     }
  162.                     return ds;
  163.                 }
  164.             }
  165.         }
  166.  
  167.         public static DataTable ExcelToDataTable(string excelPath, string sheetName, bool firstRowAsHeader = true)
  168.         {
  169.             using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
  170.             {
  171.                 IWorkbook workbook;
  172.                 IFormulaEvaluator evaluator;
  173.                 GetWorkBook(excelPath, fileStream, out workbook, out evaluator);
  174.                 return ExcelToDataTable(workbook.GetSheet(sheetName), evaluator, firstRowAsHeader);
  175.             }
  176.         }
  177.  
  178.         public static DataTable ExcelToDataTable(string excelPath, int pageIndex,Stream stream, bool firstRowAsHeader = true)
  179.         {
  180.             using (Stream fileStream = stream)
  181.             {
  182.                 IWorkbook workbook;
  183.                 IFormulaEvaluator evaluator;
  184.                 GetWorkBook(excelPath, fileStream, out workbook, out evaluator);
  185.                 return ExcelToDataTable(workbook.GetSheetAt(pageIndex), evaluator, firstRowAsHeader);
  186.             }
  187.         }
  188.  
  189.         public static DataTable ExcelToDataTable(string excelPath, int pageIndex, bool firstRowAsHeader = true)
  190.         {
  191.             using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
  192.             {
  193.                 IWorkbook workbook;
  194.                 IFormulaEvaluator evaluator;
  195.                 GetWorkBook(excelPath, fileStream, out workbook, out evaluator);
  196.                 if (pageIndex > workbook.NumberOfSheets)
  197.                     throw new Exception("参数PageIndex>Excel页面总数!");
  198.                 return ExcelToDataTable(workbook.GetSheetAt(pageIndex), evaluator, firstRowAsHeader);
  199.             }
  200.         }
  201.  
  202.         private static void GetWorkBook(string excelPath, FileStream fileStream, out IWorkbook workbook, out IFormulaEvaluator evaluator, bool isUseXlsx = false)
  203.         {
  204.             workbook = null;
  205.             evaluator = null;
  206.             if (excelPath.ToLower().EndsWith(".xls") && !isUseXlsx)
  207.             {
  208.                 workbook = new HSSFWorkbook(fileStream, true);
  209.                 evaluator = new HSSFFormulaEvaluator(workbook);
  210.             }
  211.             else
  212.             {
  213.                 workbook = new XSSFWorkbook(fileStream);
  214.                 evaluator = new XSSFFormulaEvaluator(workbook);
  215.             }
  216.         }
  217.  
  218.         private static void GetWorkBook(string excelPath, Stream fileStream, out IWorkbook workbook, out IFormulaEvaluator evaluator, bool isUseXlsx = false)
  219.         {
  220.             workbook = null;
  221.             evaluator = null;
  222.             if (excelPath.ToLower().EndsWith(".xls") && !isUseXlsx)
  223.             {
  224.                 workbook = new HSSFWorkbook(fileStream, true);
  225.                 evaluator = new HSSFFormulaEvaluator(workbook);
  226.             }
  227.             else
  228.             {
  229.                 workbook = new XSSFWorkbook(fileStream);
  230.                 evaluator = new XSSFFormulaEvaluator(workbook);
  231.             }
  232.         }
  233.  
  234.         #region 内部方法
  235.         private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator, bool firstRowAsHeader)
  236.         {
  237.             if (firstRowAsHeader)
  238.             {
  239.                 return ExcelToDataTableFirstRowAsHeader(sheet, evaluator);
  240.             }
  241.             else
  242.             {
  243.                 return ExcelToDataTable(sheet, evaluator);
  244.             }
  245.         }
  246.         private static DataTable ExcelToDataTableFirstRowAsHeader(ISheet sheet, IFormulaEvaluator evaluator)
  247.         {
  248.             using (DataTable dt = new DataTable())
  249.             {
  250.                 IRow firstRow = sheet.GetRow(0) as IRow;
  251.                 int cellCount = GetCellCount(sheet);
  252.                 for (int i = 0; i < cellCount; i++)
  253.                 {
  254.                     if (firstRow.GetCell(i) != null)
  255.                     {
  256.                         dt.Columns.Add(firstRow.GetCell(i).StringCellValue ?? string.Format("F{0}", i + 1), typeof(string));
  257.                     }
  258.                     else
  259.                     {
  260.                         dt.Columns.Add(string.Format("F{0}", i + 1), typeof(string));
  261.                     }
  262.                 }
  263.                 for (int i = 1; i <= sheet.LastRowNum; i++)
  264.                 {
  265.                     IRow row = sheet.GetRow(i) as IRow;
  266.                     DataRow dr = dt.NewRow();
  267.                     FillDataRowByHSSFRow(row, evaluator, ref dr);
  268.                     dt.Rows.Add(dr);
  269.                 }
  270.                 dt.TableName = sheet.SheetName;
  271.                 return dt;
  272.             }
  273.         }
  274.         private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator)
  275.         {
  276.             using (DataTable dt = new DataTable())
  277.             {
  278.                 if (sheet.LastRowNum != 0)
  279.                 {
  280.                     int cellCount = GetCellCount(sheet);
  281.                     for (int i = 0; i < cellCount; i++)
  282.                     {
  283.                         dt.Columns.Add(string.Format("F{0}", i), typeof(string));
  284.                     }
  285.                     for (int i = 0; i < sheet.FirstRowNum; ++i)
  286.                     {
  287.                         DataRow dr = dt.NewRow();
  288.                         dt.Rows.Add(dr);
  289.                     }
  290.  
  291.                     for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; i++)
  292.                     {
  293.                         IRow row = sheet.GetRow(i) as IRow;
  294.                         DataRow dr = dt.NewRow();
  295.                         FillDataRowByHSSFRow(row, evaluator, ref dr);
  296.                         dt.Rows.Add(dr);
  297.                     }
  298.                 }
  299.                 dt.TableName = sheet.SheetName;
  300.                 return dt;
  301.             }
  302.         }
  303.         private static void FillDataRowByHSSFRow(IRow row, IFormulaEvaluator evaluator, ref DataRow dr)
  304.         {
  305.             if (row != null)
  306.             {
  307.                 for (int j = 0; j < dr.Table.Columns.Count; j++)
  308.                 {
  309.                     ICell cell = row.GetCell(j) as ICell;
  310.                     if (cell != null)
  311.                     {
  312.                         switch (cell.CellType)
  313.                         {
  314.                             case CellType.Blank:
  315.                                 dr[j] = DBNull.Value;
  316.                                 break;
  317.                             case CellType.Boolean:
  318.                                 dr[j] = cell.BooleanCellValue;
  319.                                 break;
  320.                             case CellType.Numeric:
  321.                                 if (DateUtil.IsCellDateFormatted(cell))
  322.                                     dr[j] = cell.DateCellValue;
  323.                                 else
  324.                                     dr[j] = cell.NumericCellValue;
  325.                                 break;
  326.                             case CellType.String:
  327.                                 dr[j] = cell.StringCellValue;
  328.                                 break;
  329.                             case CellType.Error:
  330.                                 dr[j] = cell.ErrorCellValue;
  331.                                 break;
  332.                             case CellType.Formula:
  333.                                 cell = evaluator.EvaluateInCell(cell) as ICell;
  334.                                 dr[j] = cell.ToString();
  335.                                 break;
  336.                             default:
  337.                                 throw new NotSupportedException(string.Format("Catched unhandle CellType[{0}]", cell.CellType));
  338.                         }
  339.                     }
  340.                 }
  341.             }
  342.         }
  343.         private static int GetCellCount(ISheet sheet)
  344.         {
  345.             int firstRowNum = sheet.FirstRowNum;
  346.             int cellCount = 0;
  347.             for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; ++i)
  348.             {
  349.                 IRow row = sheet.GetRow(i) as IRow;
  350.                 if (row != null && row.LastCellNum > cellCount)
  351.                 {
  352.                     cellCount = row.LastCellNum;
  353.                 }
  354.             }
  355.             return cellCount;
  356.         }
  357.  
  358.         #endregion
  359.  
  360.         #region 用于Web导出
  361.         /// <summary>
  362.         /// 用于Web导出
  363.         /// </summary>
  364.         /// <param name="dtSource">源DataTable</param>
  365.         /// <param name="strHeaderText">表头文本</param>
  366.         /// <param name="strFileName">文件名</param>
  367.         public static void ExportByWeb(DataTable dtSource, string strHeaderText, string strFileName)
  368.         {
  369.             HttpContext curContext = HttpContext.Current;
  370.             try
  371.             {
  372.                 // 设置编码和附件格式
  373.                 curContext.Response.ContentType = "application/vnd.ms-excel";
  374.                 curContext.Response.ContentEncoding = Encoding.UTF8;
  375.                 curContext.Response.Charset = "";
  376.                 curContext.Response.AppendHeader("Content-Disposition",
  377.                     "attachment;filename=" + HttpUtility.UrlEncode(strFileName, Encoding.UTF8));
  378.  
  379.                 curContext.Response.BinaryWrite(Export(dtSource, strHeaderText).GetBuffer());
  380.                 curContext.Response.End();
  381.             }
  382.             catch (Exception e)
  383.             {
  384.  
  385.                 throw;
  386.             }
  387.  
  388.         }
  389.         #endregion
  390.  
  391.         #region DataTable导出到Excel的MemoryStream
  392.         /// <summary>
  393.         /// DataTable导出到Excel的MemoryStream
  394.         /// </summary>
  395.         /// <param name="dtSource">源DataTable</param>
  396.         /// <param name="strHeaderText">表头文本</param>
  397.         public static MemoryStream Export(DataTable dtSource, string strHeaderText)
  398.         {
  399.             HSSFWorkbook workbook = new HSSFWorkbook();
  400.             ISheet sheet = workbook.CreateSheet();
  401.  
  402.             #region 右击文件 属性信息
  403.             {
  404.                 DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
  405.                 dsi.Company = "NPOI";
  406.                 workbook.DocumentSummaryInformation = dsi;
  407.  
  408.                 SummaryInformation si = PropertySetFactory.CreateSummaryInformation();
  409.                /* si.Author = "文件作者信息"; //填加xls文件作者信息
  410.                 si.ApplicationName = "创建程序信息"; //填加xls文件创建程序信息
  411.                 si.LastAuthor = "最后保存者信息"; //填加xls文件最后保存者信息
  412.                 si.Comments = "作者信息"; //填加xls文件作者信息
  413.                 si.Title = "标题信息"; //填加xls文件标题信息
  414.                 si.Subject = "主题信息";//填加文件主题信息*/
  415.                 si.CreateDateTime = DateTime.Now;
  416.                 workbook.SummaryInformation = si;
  417.             }
  418.             #endregion
  419.  
  420.             ICellStyle dateStyle = workbook.CreateCellStyle();
  421.             IDataFormat format = workbook.CreateDataFormat();
  422.             dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");
  423.  
  424.             //取得列宽
  425.             int[] arrColWidth = new int[dtSource.Columns.Count];
  426.             foreach (DataColumn item in dtSource.Columns)
  427.             {
  428.                 arrColWidth[item.Ordinal] = Encoding.GetEncoding(936).GetBytes(item.ColumnName.ToString()).Length;
  429.             }
  430.             for (int i = 0; i < dtSource.Rows.Count; i++)
  431.             {
  432.                 for (int j = 0; j < dtSource.Columns.Count; j++)
  433.                 {
  434.                     int intTemp = Encoding.GetEncoding(936).GetBytes(dtSource.Rows[i][j].ToString()).Length;
  435.                     if (intTemp > arrColWidth[j])
  436.                     {
  437.                         arrColWidth[j] = intTemp;
  438.                     }
  439.                 }
  440.             }
  441.             int rowIndex = 0;
  442.             foreach (DataRow row in dtSource.Rows)
  443.             {
  444.                 #region 新建表，填充表头，填充列头，样式
  445.                 if (rowIndex == 65535 || rowIndex == 0)
  446.                 {
  447.                     if (rowIndex != 0)
  448.                     {
  449.                         sheet = workbook.CreateSheet();
  450.                     }
  451.  
  452.                     #region 表头及样式
  453.                     {
  454.                         IRow headerRow = sheet.CreateRow(0);
  455.                         headerRow.HeightInPoints = 25;
  456.                         headerRow.CreateCell(0).SetCellValue(strHeaderText);
  457.  
  458.                         ICellStyle headStyle = workbook.CreateCellStyle();
  459.                        // headStyle.Alignment = HorizontalAlignment.CENTER;
  460.                         IFont font = workbook.CreateFont();
  461.                         font.FontHeightInPoints = 20;
  462.                         font.Boldweight = 700;
  463.                         headStyle.SetFont(font);
  464.                         headerRow.GetCell(0).CellStyle = headStyle;
  465.                         sheet.AddMergedRegion(new CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));
  466.                         //headerRow.Dispose();
  467.                     }
  468.                     #endregion
  469.  
  470.                     #region 列头及样式
  471.                     {
  472.                         IRow headerRow = sheet.CreateRow(1);
  473.                         ICellStyle headStyle = workbook.CreateCellStyle();
  474.                        // headStyle.Alignment = HorizontalAlignment.CENTER;
  475.                         IFont font = workbook.CreateFont();
  476.                         font.FontHeightInPoints = 10;
  477.                         font.Boldweight = 700;
  478.                         headStyle.SetFont(font);
  479.                         foreach (DataColumn column in dtSource.Columns)
  480.                         {
  481.                             headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
  482.                             headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
  483.  
  484.                             //设置列宽
  485.                             sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256);
  486.                         }
  487.                         //headerRow.Dispose();
  488.                     }
  489.                     #endregion
  490.  
  491.                     rowIndex = 2;
  492.                 }
  493.                 #endregion
  494.  
  495.                 #region 填充内容
  496.                 IRow dataRow = sheet.CreateRow(rowIndex);
  497.                 foreach (DataColumn column in dtSource.Columns)
  498.                 {
  499.                     ICell newCell = dataRow.CreateCell(column.Ordinal);
  500.  
  501.                     string drValue = row[column].ToString();
  502.  
  503.                     switch (column.DataType.ToString())
  504.                     {
  505.                         case "System.String"://字符串类型
  506.                             newCell.SetCellValue(drValue);
  507.                             break;
  508.                         case "System.DateTime"://日期类型
  509.                             DateTime dateV;
  510.                             DateTime.TryParse(drValue, out dateV);
  511.                             newCell.SetCellValue(dateV);
  512.  
  513.                             newCell.CellStyle = dateStyle;//格式化显示
  514.                             break;
  515.                         case "System.Boolean"://布尔型
  516.                             bool boolV = false;
  517.                             bool.TryParse(drValue, out boolV);
  518.                             newCell.SetCellValue(boolV);
  519.                             break;
  520.                         case "System.Int16"://整型
  521.                         case "System.Int32":
  522.                         case "System.Int64":
  523.                         case "System.Byte":
  524.                             int intV = 0;
  525.                             int.TryParse(drValue, out intV);
  526.                             newCell.SetCellValue(intV);
  527.                             break;
  528.                         case "System.Decimal"://浮点型
  529.                         case "System.Double":
  530.                             double doubV = 0;
  531.                             double.TryParse(drValue, out doubV);
  532.                             newCell.SetCellValue(doubV);
  533.                             break;
  534.                         case "System.DBNull"://空值处理
  535.                             newCell.SetCellValue("");
  536.                             break;
  537.                         default:
  538.                             newCell.SetCellValue("");
  539.                             break;
  540.                     }
  541.  
  542.                 }
  543.                 #endregion
  544.  
  545.                 rowIndex++;
  546.             }
  547.             using (MemoryStream ms = new MemoryStream())
  548.             {
  549.                 workbook.Write(ms);
  550.                 ms.Flush();
  551.                 ms.Position = 0;
  552.  
  553.                 //sheet.Dispose();
  554.                 //workbook.Dispose();//一般只用写这一个就OK了，他会遍历并释放所有资源，但当前版本有问题所以只释放sheet
  555.                 return ms;
  556.             }
  557.         }
  558.         #endregion
  559.  
  560.     }

　　

NPOIHelper的更多相关文章

  1. 分享一个前辈的NPOIhelper

    即拿即用: 首先要下载npoi的dll,此不赘述,接着添加引用: using NPOI.HPSF; using NPOI.HSSF.UserModel; using NPOI.SS.UserModel ...

  2. NPOIHelper.cs (NPOI 2.1.1)

    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.D ...

  3. C#利用NPOI处理excel的类 NPOIHelper.cs

    个人的NPOIHelp类,包括datatable导出到excel,dataset导出到excel,excel导入到datatable,excel导入到dataset, 更新excel中的数据,验证导入 ...

  4. 基于NPOI的Excel数据导入

    从Excel导入数据最令人头疼的是数据格式的兼容性,特别是日期类型的兼容性.为了能够无脑导入日期,折腾了一天的NPOI.在经过测试确实可以导入任意格式的合法日期后,写下这篇小文,与大家共享.完整代码请 ...

  5. 基于NPOI导出和导入Excel

    概述 NPOI,顾名思义,就是POI的.NET版本.NPOI就是用.NET语言编写的一套数据导出Excel的开源项目,支持XML.xls.xlsx.ppt等格式..NET不仅实现Excel导出还可以实 ...

  6. NPOI操作Excel辅助类

    /// <summary> /// NPOI操作excel辅助类 /// </summary> public static class NPOIHelper { #region ...

  7. npoi批量导入实现及相关技巧

    批量导入功能对于大部分后台系统来说都是不可或缺的一部分,常见的场景-基础数据的录入(部门,用户),用批量导入方便快捷.最近项目需要用到批量导入,决定花点时间写套比较通用的Excel导入功能.经过考虑, ...

  8. Aspose.Cells 首次使用，用到模版填充数据，合并单元格，换行

    Aspose.Cells 首次使用,用到模版填充数据,合并单元格,换行 模版格式,图格式是最简单的格式,但实际效果不是这种,实际效果图如图2 图2 ,注意看红色部分,一对一是正常的,但是有一对多的订单 ...

  9. [Solution] NPOI操作Excel

    NPOI 是 POI 项目的 .NET 版本.POI是一个开源的Java读写Excel.WORD等微软OLE2组件文档的项目.使用 NPOI 你就可以在没有安装 Office 或者相应环境的机器上对 ...

随机推荐

  1. ARM汇编

    ARM汇编 ISA ISA即指指令集架构(Instruction Set Architecture)是与程序设计有关的计算机架构的一部分,包括本地数据类型.指令.寄存器.地址模式.内存架构.中断和意外 ...

  2. 使用js实现input输入框的增加

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  3. HDU 1839

    http://acm.hdu.edu.cn/showproblem.php?pid=1839 题意:从1到n,要求时间小于等于T到达.每条边有一个容量,问最多能运多少货物. 分析:最多能运的货物取决于 ...

  4. 一个简单的python程序

    假设我们有这么一项任务:简单测试局域网中的电脑是否连通.这些电脑的ip范围从192.168.0.101到192.168.0.200. import subprocesscmd="cmd.ex ...

  5. ”未在本地计算机上注册“microsoft.et.OLEDB.4.0”提供程序。“解决方案大集合

    本人在做一个连接Access数据库的时候,程序扔给我一个如此Bug——“未在本地计算机上注册“microsoft.et.OLEDB.4.0”, 请教度娘,告诉我可能是如下因素: 一.“设置应用程序池默 ...

  6. android 底层入门开发（二）

    LED将为我闪烁:控制发光二极管 对于大多数Linux驱动来说,需要直接与硬件交互,本章主要介绍用Linux驱动来控制二极管的明暗,即通过Linux驱动发送数据控制开发板上LED灯的开关. 第一节介绍 ...

  7. Swift笔记

    最近从Xcode6 beta4开始到现在的Xcode6.0.1,使用Swift一段时间了,Swift大体来说,语法与java.c++比较接近,相比objective-c要友好多了,也更容易上手,这里记 ...

  8. XJOI‘s story （不定期连载）

    王城双基的力量.... 我也不知道写写这种东西会不会被查大表..尴尬  . 我为什么要写这东西: 为了蛤鸡 为了红太阳 xj 人物列传 2017   1,6   Friday 得到大新闻 机房后面的监 ...

  9. CE 定时器

    //头文件: afx_msg void OnTimer(UINT_PTR nIDEvent); //声明定时器响应函数 //代码文件: #define TIMER 1 #define TIMEROUT ...

  10. A log about Reading the memroy of Other Process in C++/WIN API--ReadProcessMemory()

    Memory, is a complex module in Programing, especially on Windows. This time, I use cpp with win wind ...