1674 lines
89 KiB
C#
1674 lines
89 KiB
C#
using System;
|
|
using System.Data;
|
|
using System.Data.OleDb;
|
|
using GThinking.N_MISPROAS;
|
|
using NPOI.HSSF.UserModel;
|
|
using System.IO;
|
|
using NPOI.SS.UserModel;
|
|
using NPOI.XSSF.UserModel;
|
|
using NPOI.SS.Util;
|
|
using System.Text.RegularExpressions;
|
|
using System.Collections.Generic;
|
|
using NPOI.HSSF.Util;
|
|
|
|
namespace GThinking.N_MISPRO.Data
|
|
{
|
|
/// <summary>
|
|
/// Excel转DataSet类
|
|
/// </summary>
|
|
public class TExcelData : IDisposable
|
|
{
|
|
private string m_path;
|
|
private OleDbConnection m_conn;
|
|
private bool m_hasHeaderRow;
|
|
private bool m_delfile;
|
|
private static bool bOLEDB = true;
|
|
|
|
/// <summary>
|
|
/// 构造函数。
|
|
/// </summary>
|
|
/// <param name="path">要打开的EXCEL文件。</param>
|
|
public TExcelData(string path, bool delfile)
|
|
{
|
|
m_path = path;
|
|
m_hasHeaderRow = true;
|
|
m_delfile = delfile;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 构造函数。
|
|
/// </summary>
|
|
/// <param name="path">要打开的EXCEL文件。</param>
|
|
/// <param name="hasHeaderRow">Excel第一行是否是标题行。</param>
|
|
public TExcelData(string path, bool hasHeaderRow, bool delfile)
|
|
{
|
|
m_path = path;
|
|
m_hasHeaderRow = hasHeaderRow;
|
|
m_delfile = delfile;
|
|
}
|
|
|
|
public virtual void Close()
|
|
{
|
|
this.Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (m_conn == null)
|
|
return;
|
|
if (m_conn.State == ConnectionState.Open)
|
|
{
|
|
m_conn.Dispose();
|
|
m_conn = null;
|
|
}
|
|
if (m_delfile)
|
|
{
|
|
if (System.IO.File.Exists(m_path))
|
|
System.IO.File.Delete(m_path);
|
|
}
|
|
}
|
|
|
|
~TExcelData()
|
|
{
|
|
if (this.m_conn != null)
|
|
{
|
|
this.Dispose(false);
|
|
}
|
|
}
|
|
|
|
// 根据32/64位运行时返回不同的连接字符串。
|
|
private string GetConnString()
|
|
{
|
|
string conn;
|
|
if (AppRuntime.BitType == AppBitType.Bit32)
|
|
{
|
|
// 以文本类型读取混合类型列。Jet.OLEDB提供程序将返回前8行占多数的类型的数据，对于占少数的数据类型，则会返回 NULL（空）值。如果该列中两种类型数据的数量相等，将优先选择数字型数据，放弃文本型数据。
|
|
if (m_hasHeaderRow)
|
|
conn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + m_path + @";Extended Properties=""Excel 8.0;IMEX=1;ImportMixedTypes=Text;"";";
|
|
else
|
|
conn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + m_path + @";Extended Properties=""Excel 8.0;IMEX=1;ImportMixedTypes=Text;HDR=NO;"";";
|
|
}
|
|
else // AppBitType.Bit64
|
|
{
|
|
if (m_hasHeaderRow)
|
|
conn = "Provider=Microsoft.ACE.OLEDB.12.0;" + "Data Source=" + m_path + ";" + @"Extended Properties=""Excel 8.0;IMEX=1;ImportMixedTypes=Text;"";";
|
|
else
|
|
conn = "Provider=Microsoft.ACE.OLEDB.12.0;" + "Data Source=" + m_path + ";" + @"Extended Properties=""Excel 8.0;IMEX=1;ImportMixedTypes=Text;HDR=NO;"";";
|
|
}
|
|
return conn;
|
|
}
|
|
|
|
// 确保连接已经打开。
|
|
private void EnsureOpen()
|
|
{
|
|
if ((m_conn != null) && (m_conn.State == ConnectionState.Open))
|
|
return;
|
|
|
|
string connStr = GetConnString();
|
|
m_conn = new OleDbConnection(connStr);
|
|
m_conn.Open();
|
|
}
|
|
|
|
//
|
|
private string GetFirstSheetName()
|
|
{
|
|
EnsureOpen();
|
|
DataTable sheetNames = m_conn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new object[] { null, null, null, "TABLE" });
|
|
return sheetNames.Rows[0].Table.Rows[0]["TABLE_NAME"].ToString().Trim();
|
|
}
|
|
|
|
public DataSet OpenDataSet(string sql)
|
|
{
|
|
EnsureOpen();
|
|
DataSet ds = new DataSet();
|
|
OleDbDataAdapter ad = new OleDbDataAdapter(sql, m_conn);
|
|
ad.Fill(ds, "table1");
|
|
return ds;
|
|
}
|
|
|
|
public DataTable OpenDataTable(string sql)
|
|
{
|
|
EnsureOpen();
|
|
DataTable dt = new DataTable("table1");
|
|
OleDbDataAdapter ad = new OleDbDataAdapter(sql, m_conn);
|
|
ad.Fill(dt);
|
|
return dt;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取Excel中指定Sheet的数据到Dataset中。
|
|
/// </summary>
|
|
/// <param name="path">Excel文件路径。</param>
|
|
/// <param name="SheetName">sheet名称。</param>
|
|
/// <param name="columns">读取数据的栏目。</param>
|
|
/// <param name="deleteFile">读取数据后是否删除临时excel文件。</param>
|
|
/// <param name="errorMessage">错误信息。</param>
|
|
/// <returns>如果读取数据正常，返回数据集；否则，返回null，在errorMessage含有异常信息。</returns>
|
|
public static DataSet ReadExcel(string path, string sheetName, string columns, bool deleteFile, ref string errorMessage)
|
|
{
|
|
PlatformID pid = Environment.OSVersion.Platform;
|
|
if (pid == PlatformID.Unix)
|
|
bOLEDB = false;
|
|
if (bOLEDB)
|
|
return ReadExcel(path, sheetName, columns, true, deleteFile, ref errorMessage);
|
|
else
|
|
return ReadExcel_NPOI(path, sheetName, 0, true, ref errorMessage);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取Excel中指定Sheet的数据到Dataset中--。
|
|
/// </summary>
|
|
/// <param name="path">Excel文件路径。</param>
|
|
/// <param name="SheetName">sheet名称。</param>
|
|
/// <param name="columns">读取数据的栏目。</param>
|
|
/// <param name="hasHeaderRow">Excel第一行是否是标题行。</param>
|
|
/// <param name="deleteFile">读取数据后是否删除临时excel文件。</param>
|
|
/// <param name="errorMessage">错误信息。</param>
|
|
/// <returns>如果读取数据正常，返回数据集；否则，返回null，在errorMessage含有异常信息。</returns>
|
|
public static DataSet ReadExcel(string path, string sheetName, string columns, bool hasHeaderRow, bool deleteFile, ref string errorMessage)
|
|
{
|
|
if (bOLEDB)
|
|
{
|
|
string sOldSheet = sheetName;
|
|
try
|
|
{
|
|
|
|
using (TExcelData excel = new TExcelData(path, hasHeaderRow, deleteFile))
|
|
{
|
|
// 如果未指定Sheet名，则使用按Sheet名称排序后的第一个Sheet。
|
|
if (sheetName.Trim().Equals(""))
|
|
sheetName = excel.GetFirstSheetName();
|
|
else
|
|
sheetName = sheetName + "$";
|
|
|
|
string sql;
|
|
if (string.IsNullOrEmpty(columns))
|
|
{
|
|
sql = "select * from [" + sheetName + "]";
|
|
}
|
|
else
|
|
{
|
|
sql = "select " + columns + " from [" + sheetName + "]";
|
|
}
|
|
return excel.OpenDataSet(sql);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
if (errorMessage.Contains("注册") || (errorMessage.IndexOf("OLEDB", StringComparison.OrdinalIgnoreCase) >= 0) || errorMessage.Contains("OleDb"))
|
|
bOLEDB = false;
|
|
else
|
|
return null;
|
|
}
|
|
try
|
|
{
|
|
if (!bOLEDB)
|
|
{
|
|
errorMessage = "";
|
|
return ReadExcel_NPOI(path, sOldSheet, 0, hasHeaderRow, ref errorMessage);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
if (errorMessage.Contains("注册") || (errorMessage.IndexOf("OLEDB", StringComparison.OrdinalIgnoreCase) >= 0))
|
|
bOLEDB = false;
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return ReadExcel_NPOI(path, sheetName, 0, hasHeaderRow, ref errorMessage);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据查询语句读取Excel中的数据到Dataset中。
|
|
/// </summary>
|
|
/// <param name="path">Excel文件路径。</param>
|
|
/// <param name="sql">查询的sql语句。</param>
|
|
/// <param name="deleteFile">读取数据后是否删除临时excel文件。</param>
|
|
/// <param name="errorMessage">错误信息。</param>
|
|
/// <returns>如果读取数据正常，返回数据集；否则，返回null，在errorMessage含有异常信息。</returns>
|
|
public static DataSet ReadExcel(string path, string sql, bool deleteFile, ref string errorMessage)
|
|
{
|
|
PlatformID pid = Environment.OSVersion.Platform;
|
|
if (pid == PlatformID.Unix)
|
|
bOLEDB = false;
|
|
if (bOLEDB)
|
|
return ReadExcel(path, sql, true, deleteFile, ref errorMessage);
|
|
else
|
|
return ReadExcel_NPOI(path, 0, true, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据查询语句读取Excel中的数据到Dataset中。
|
|
/// </summary>
|
|
/// <param name="path">Excel文件路径。</param>
|
|
/// <param name="sql">查询的sql语句。</param>
|
|
/// <param name="hasHeaderRow">Excel第一行是否是标题行。</param>
|
|
/// <param name="deleteFile">读取数据后是否删除临时excel文件。</param>
|
|
/// <param name="errorMessage">错误信息。</param>
|
|
/// <returns>如果读取数据正常，返回数据集；否则，返回null，在errorMessage含有异常信息。</returns>
|
|
public static DataSet ReadExcel(string path, string sql, bool hasHeaderRow, bool deleteFile, ref string errorMessage)
|
|
{
|
|
try
|
|
{
|
|
using (TExcelData excel = new TExcelData(path, hasHeaderRow, deleteFile))
|
|
{
|
|
if (sql.Trim().Equals(""))
|
|
{
|
|
errorMessage = "查询语句为空！";
|
|
return null;
|
|
}
|
|
|
|
return excel.OpenDataSet(sql);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取Excel文件返回DataSet。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_NPOI(string filePath, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
return ReadExcel_NPOI(filePath, "", fromRowIndex, hasHeaderRow, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取Excel文件返回DataSet。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="SheetName">Sheet名</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_NPOI(string filePath, string SheetName, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
string[] sheetNames = new string[1];
|
|
sheetNames[0] = SheetName;
|
|
return ReadExcel_NPOI(filePath, sheetNames, fromRowIndex, hasHeaderRow, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取Excel文件返回DataSet。循环sheetName数组里每一个sheetName读取到一个DataTable里。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="sheetNames">sheetName数组</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_NPOI(string filePath, string[] sheetNames, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
try
|
|
{
|
|
DataSet ds = new DataSet();
|
|
|
|
if (sheetNames == null)
|
|
return ds;
|
|
else
|
|
{
|
|
HSSFWorkbook wk = null;
|
|
FileStream fs = File.OpenRead(filePath);
|
|
wk = new HSSFWorkbook(fs);//把xls文件中的数据写入wk中
|
|
//wk = new XSSFWorkbook(fs);//把xlsx文件中的数据写入wk中，暂不支持
|
|
fs.Close();
|
|
|
|
for (int k = 0; k < sheetNames.Length; k++)
|
|
{
|
|
string SheetName = sheetNames[k].Trim();
|
|
ISheet sheet = SheetName.Equals("") ? wk.GetSheetAt(0) : wk.GetSheet(SheetName);
|
|
if (sheet == null)
|
|
continue;
|
|
SheetName = sheet.SheetName;
|
|
|
|
if (ds.Tables.Contains(SheetName))
|
|
continue;
|
|
else
|
|
ds.Tables.Add(SheetName);
|
|
|
|
int minCellNum = -1;//最小有效列数
|
|
int maxCellNum = -1;//最大有效列数
|
|
for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; i++)
|
|
{
|
|
IRow iRow = sheet.GetRow(i);
|
|
if (iRow != null && iRow.Cells.Count > 0)
|
|
{
|
|
if (minCellNum == -1)
|
|
minCellNum = iRow.FirstCellNum;
|
|
else
|
|
{
|
|
if (iRow.FirstCellNum < minCellNum)
|
|
minCellNum = iRow.FirstCellNum;
|
|
}
|
|
if (maxCellNum == -1)
|
|
maxCellNum = iRow.LastCellNum;
|
|
else
|
|
{
|
|
if (iRow.LastCellNum > maxCellNum)
|
|
maxCellNum = iRow.LastCellNum;
|
|
}
|
|
}
|
|
}
|
|
|
|
IRow headerRow = sheet.GetRow(fromRowIndex);
|
|
//添加列
|
|
for (int i = minCellNum; i < maxCellNum; i++)
|
|
{
|
|
if (i < headerRow.FirstCellNum || i >= headerRow.LastCellNum)
|
|
{
|
|
DataColumn column = new DataColumn("F" + Convert.ToString(i + 1));
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
else
|
|
{
|
|
if (hasHeaderRow)//第一行为标题行
|
|
{
|
|
DataColumn column = new DataColumn(headerRow.GetCell(i) == null ? " " : headerRow.GetCell(i).StringCellValue);
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
else
|
|
{
|
|
DataColumn column = new DataColumn("F" + Convert.ToString(i + 1));
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
}
|
|
}
|
|
//添加行
|
|
int iFirstLine = fromRowIndex;
|
|
if (hasHeaderRow)
|
|
iFirstLine = fromRowIndex + 1;
|
|
for (int i = iFirstLine; i <= sheet.LastRowNum; i++)
|
|
{
|
|
IRow row = sheet.GetRow(i);
|
|
DataRow dataRow = ds.Tables[SheetName].NewRow();
|
|
|
|
if (row != null && row.Cells.Count > 0)
|
|
{
|
|
for (int j = row.FirstCellNum; j < row.LastCellNum; j++)
|
|
{
|
|
if (row.GetCell(j) != null)
|
|
dataRow[j] = GetCellValue(row.GetCell(j));
|
|
}
|
|
}
|
|
ds.Tables[SheetName].Rows.Add(dataRow);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ds;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_NPOI(string filePath, DataSet ds, ref string errorMessage)
|
|
{
|
|
CreateExcel_NPOI(filePath, ds, true, null, null, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <param name="ColNameFirstRow">DataSet的栏目名是否作为Excel的第一行，一般为true</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_NPOI(string filePath, DataSet ds, bool ColNameFirstRow, ref string errorMessage)
|
|
{
|
|
CreateExcel_NPOI(filePath, ds, ColNameFirstRow, null, null, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <param name="ColNameFirstRow">DataSet的栏目名是否作为Excel的第一行，一般为true</param>
|
|
/// <param name="CellData">给指定单元格增加批注 参数一：指定单元格的位置，比如A1、B2、AA1、AAA1参数二：指定单元格上显示的批注内容</param>
|
|
/// <param name="SheetData">设置单元格格式为自定义格式 参数一：指定栏目位置，比如A、B、C 参数二：设置单元格自定义格式，比如"#,##0.00;-#,##0.00;#"代表两位小数</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_NPOI(string filePath, DataSet ds, bool ColNameFirstRow, NpoiCellData CellData, NpoiSheetData SheetData, ref string errorMessage)
|
|
{
|
|
try
|
|
{
|
|
if (ds.Tables.Count <= 0)
|
|
return;
|
|
|
|
if (string.IsNullOrEmpty(filePath))
|
|
return;
|
|
|
|
HSSFWorkbook work = new HSSFWorkbook();
|
|
|
|
for (int i = 0; i < ds.Tables.Count; i++)
|
|
{
|
|
ISheet sheet = work.CreateSheet(ds.Tables[i].TableName);
|
|
if (SheetData != null)
|
|
sheet.CreateFreezePane(SheetData.FreezePaneCols, SheetData.FreezePaneRows);
|
|
|
|
//设置栏目头和行内容的字体样式
|
|
ICellStyle cellHeadStyleDefault = work.CreateCellStyle();
|
|
ICellStyle cellStyleDefault = work.CreateCellStyle();
|
|
IFont fontHead = work.CreateFont();
|
|
fontHead.FontHeightInPoints = 9;
|
|
fontHead.FontName = "宋体";
|
|
cellHeadStyleDefault.SetFont(fontHead);
|
|
cellHeadStyleDefault.Alignment = HorizontalAlignment.Center;
|
|
cellHeadStyleDefault.FillForegroundColor = HSSFColor.Grey25Percent.Index;
|
|
cellHeadStyleDefault.FillPattern = FillPattern.SolidForeground;
|
|
IFont font = work.CreateFont();
|
|
font.FontHeightInPoints = 9;
|
|
font.FontName = "宋体";
|
|
cellStyleDefault.SetFont(font);
|
|
|
|
//用户指定了栏目格式的，按栏目创建好ICellStyle，方便下方循环单元格时直接使用
|
|
Dictionary<string, ICellStyle> dicColumnStyle = new Dictionary<string, ICellStyle>();
|
|
Dictionary<string, string> dicColumnFormula = new Dictionary<string, string>();
|
|
if (SheetData != null)
|
|
{
|
|
if (SheetData.ColumnStyle != null)
|
|
{
|
|
IDataFormat format = work.CreateDataFormat();//日期、数值类型的指定
|
|
foreach (string col in SheetData.ColumnStyle.Keys)
|
|
{
|
|
ICellStyle cellStyleEx = work.CreateCellStyle();
|
|
string sformula = "";
|
|
cellStyleEx.SetFont(font);
|
|
NpoiColumnStyle tCellStyle = SheetData.ColumnStyle[col];
|
|
if (tCellStyle != null && !tCellStyle.DataFormat.Equals(""))
|
|
{
|
|
cellStyleEx.DataFormat = format.GetFormat(tCellStyle.DataFormat);
|
|
sformula = tCellStyle.Formula;
|
|
}
|
|
dicColumnStyle.Add(col, cellStyleEx);
|
|
dicColumnFormula.Add(col, sformula);
|
|
sheet.SetDefaultColumnStyle(columnNameToIndex(col), cellStyleEx);
|
|
|
|
if (tCellStyle != null && tCellStyle.ColWidth != -1.0)
|
|
{
|
|
sheet.SetColumnWidth(columnNameToIndex(col), Pixel2ExcelWidth(tCellStyle.ColWidth));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (ColNameFirstRow)
|
|
{
|
|
IRow colrow = sheet.CreateRow(0);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
string sColumnName = ds.Tables[i].Columns[j].Caption.Trim();
|
|
if (sColumnName.Equals(""))
|
|
sColumnName = ds.Tables[i].Columns[j].ColumnName.Trim();
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
cell = colrow.CreateCell(j, CellType.String);//栏目行固定是String类型
|
|
cell.CellStyle = cellHeadStyleDefault;
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(sColumnName); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(sColumnName, out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(sColumnName, out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(sColumnName); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(sColumnName); break;
|
|
default: cell.SetCellValue(sColumnName); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = colrow.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellHeadStyleDefault;
|
|
cell.SetCellValue(sColumnName);
|
|
}
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);//取坐标位置
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new HSSFClientAnchor(j, 0, j + 1, 0 + 2, j + 1, 0, j + 2, 2));
|
|
comment.String = new HSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle = cellStyleColor;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < ds.Tables[i].Rows.Count; k++)
|
|
{
|
|
IRow row = sheet.CreateRow(k + 1);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(ColReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[ColReference];
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = row.CreateCell(j, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = row.CreateCell(j, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = row.CreateCell(j, CellType.String); break;
|
|
default: row.CreateCell(j, CellType.String); break;
|
|
}
|
|
if (dicColumnStyle != null && dicColumnStyle.ContainsKey(ColReference))
|
|
cell.CellStyle = dicColumnStyle[ColReference];
|
|
else
|
|
cell.CellStyle = cellStyleDefault;
|
|
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
default: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
}
|
|
|
|
//设置公式
|
|
if (dicColumnFormula != null && dicColumnFormula.ContainsKey(ColReference) && !dicColumnFormula[ColReference].Equals("") && cell.CellType == CellType.String)
|
|
{
|
|
cell.CellFormula = dicColumnFormula[ColReference];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = row.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellStyleDefault;
|
|
cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim());
|
|
}
|
|
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new HSSFClientAnchor(j, k, j + 1, k + 2, j + 1, k + 1, j + 2, k + 3));
|
|
comment.String = new HSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle = cellStyleColor;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int k = 0; k < ds.Tables[i].Rows.Count; k++)
|
|
{
|
|
IRow row = sheet.CreateRow(k);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(ColReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[ColReference];
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = row.CreateCell(j, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = row.CreateCell(j, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = row.CreateCell(j, CellType.String); break;
|
|
default: row.CreateCell(j, CellType.String); break;
|
|
}
|
|
if (dicColumnStyle != null && dicColumnStyle.ContainsKey(ColReference))
|
|
cell.CellStyle = dicColumnStyle[ColReference];
|
|
else
|
|
cell.CellStyle = cellStyleDefault;
|
|
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
default: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
}
|
|
|
|
//设置公式
|
|
if (dicColumnFormula != null && dicColumnFormula.ContainsKey(ColReference) && !dicColumnFormula[ColReference].Equals("") && cell.CellType == CellType.String)
|
|
{
|
|
cell.CellFormula = dicColumnFormula[ColReference];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = row.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellStyleDefault;
|
|
cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim());
|
|
}
|
|
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new HSSFClientAnchor(j, k, j + 1, k + 2, j + 1, k + 1, j + 2, k + 3));
|
|
comment.String = new HSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle = cellStyleColor;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
using (FileStream fs = File.OpenWrite(filePath)) //打开一个xls文件，如果没有则自行创建，如果存在则在创建是不要打开该文件！
|
|
{
|
|
work.Write(fs); //向打开的这个xls文件中写入mySheet表并保存。
|
|
fs.Close();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message.Equals("") ? ex.InnerException.Message : ex.Message;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取XLSX类型Excel文件返回DataSet。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_XLSX_NPOI(string filePath, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
return ReadExcel_XLSX_NPOI(filePath, "", fromRowIndex, hasHeaderRow, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取XLSX类型Excel文件返回DataSet。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="SheetName">Sheet名</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_XLSX_NPOI(string filePath, string SheetName, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
string[] sheetNames = new string[1];
|
|
sheetNames[0] = SheetName;
|
|
return ReadExcel_XLSX_NPOI(filePath, sheetNames, fromRowIndex, hasHeaderRow, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取XLSX类型Excel文件返回DataSet。循环sheetName数组里每一个sheetName读取到一个DataTable里。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="sheetNames">sheetName数组</param>
|
|
/// <param name="fromRowIndex">从哪一行开始读取，一般为0</param>
|
|
/// <param name="hasHeaderRow">读取的第一行是否作为DataSet的栏目名，一般为true</param>
|
|
/// <returns></returns>
|
|
public static DataSet ReadExcel_XLSX_NPOI(string filePath, string[] sheetNames, int fromRowIndex, bool hasHeaderRow, ref string errorMessage)
|
|
{
|
|
try
|
|
{
|
|
DataSet ds = new DataSet();
|
|
|
|
if (sheetNames == null)
|
|
return ds;
|
|
else
|
|
{
|
|
XSSFWorkbook wk = null;
|
|
FileStream fs = File.OpenRead(filePath);
|
|
wk = new XSSFWorkbook(fs);//把xlsx文件中的数据写入wk中
|
|
fs.Close();
|
|
|
|
for (int k = 0; k < sheetNames.Length; k++)
|
|
{
|
|
string SheetName = sheetNames[k].Trim();
|
|
ISheet sheet = SheetName.Equals("") ? wk.GetSheetAt(0) : wk.GetSheet(SheetName);
|
|
if (sheet == null)
|
|
continue;
|
|
SheetName = sheet.SheetName;
|
|
|
|
if (ds.Tables.Contains(SheetName))
|
|
continue;
|
|
else
|
|
ds.Tables.Add(SheetName);
|
|
|
|
int minCellNum = -1;//最小有效列数
|
|
int maxCellNum = -1;//最大有效列数
|
|
for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; i++)
|
|
{
|
|
IRow iRow = sheet.GetRow(i);
|
|
if (iRow != null && iRow.Cells.Count > 0)
|
|
{
|
|
if (minCellNum == -1)
|
|
minCellNum = iRow.FirstCellNum;
|
|
else
|
|
{
|
|
if (iRow.FirstCellNum < minCellNum)
|
|
minCellNum = iRow.FirstCellNum;
|
|
}
|
|
if (maxCellNum == -1)
|
|
maxCellNum = iRow.LastCellNum;
|
|
else
|
|
{
|
|
if (iRow.LastCellNum > maxCellNum)
|
|
maxCellNum = iRow.LastCellNum;
|
|
}
|
|
}
|
|
}
|
|
|
|
IRow headerRow = sheet.GetRow(fromRowIndex);
|
|
//添加列
|
|
for (int i = minCellNum; i < maxCellNum; i++)
|
|
{
|
|
if (i < headerRow.FirstCellNum || i >= headerRow.LastCellNum)
|
|
{
|
|
DataColumn column = new DataColumn("F" + Convert.ToString(i + 1));
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
else
|
|
{
|
|
if (hasHeaderRow)//第一行为标题行
|
|
{
|
|
DataColumn column = new DataColumn(headerRow.GetCell(i) == null ? " " : headerRow.GetCell(i).StringCellValue);
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
else
|
|
{
|
|
DataColumn column = new DataColumn("F" + Convert.ToString(i + 1));
|
|
ds.Tables[SheetName].Columns.Add(column);
|
|
}
|
|
}
|
|
}
|
|
//添加行
|
|
int iFirstLine = fromRowIndex;
|
|
if (hasHeaderRow)
|
|
iFirstLine = fromRowIndex + 1;
|
|
for (int i = iFirstLine; i <= sheet.LastRowNum; i++)
|
|
{
|
|
IRow row = sheet.GetRow(i);
|
|
DataRow dataRow = ds.Tables[SheetName].NewRow();
|
|
|
|
if (row != null && row.Cells.Count > 0)
|
|
{
|
|
for (int j = row.FirstCellNum; j < row.LastCellNum; j++)
|
|
{
|
|
if (row.GetCell(j) != null)
|
|
dataRow[j] = GetCellValue(row.GetCell(j));
|
|
}
|
|
}
|
|
ds.Tables[SheetName].Rows.Add(dataRow);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ds;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成XLSX类型Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_XLSX_NPOI(string filePath, DataSet ds, ref string errorMessage)
|
|
{
|
|
CreateExcel_XLSX_NPOI(filePath, ds, true, null, null, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成XLSX类型Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <param name="ColNameFirstRow">DataSet的栏目名是否作为Excel的第一行，一般为true</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_XLSX_NPOI(string filePath, DataSet ds, bool ColNameFirstRow, ref string errorMessage)
|
|
{
|
|
CreateExcel_XLSX_NPOI(filePath, ds, ColNameFirstRow, null, null, ref errorMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取DataSet生成XLSX类型Excel文件。将数据集填充到指定路径的电子表格中（数据集里多个table对应电子表格的多个sheet页）。
|
|
/// </summary>
|
|
/// <param name="filePath">Excel文件全路径</param>
|
|
/// <param name="ds">数据集</param>
|
|
/// <param name="ColNameFirstRow">DataSet的栏目名是否作为Excel的第一行，一般为true</param>
|
|
/// <param name="CellData">给指定单元格增加批注 参数一：指定单元格的位置，比如A1、B2、AA1、AAA1参数二：指定单元格上显示的批注内容</param>
|
|
/// <param name="SheetData">设置单元格格式为自定义格式 参数一：指定栏目位置，比如A、B、C 参数二：设置单元格自定义格式，比如"#,##0.00;-#,##0.00;#"代表两位小数</param>
|
|
/// <returns></returns>
|
|
public static void CreateExcel_XLSX_NPOI(string filePath, DataSet ds, bool ColNameFirstRow, NpoiCellData CellData, NpoiSheetData SheetData, ref string errorMessage)
|
|
{
|
|
try
|
|
{
|
|
if (ds.Tables.Count <= 0)
|
|
return;
|
|
|
|
if (string.IsNullOrEmpty(filePath))
|
|
return;
|
|
|
|
XSSFWorkbook work = new XSSFWorkbook();
|
|
for (int i = 0; i < ds.Tables.Count; i++)
|
|
{
|
|
ISheet sheet = work.CreateSheet(ds.Tables[i].TableName);
|
|
if (SheetData != null)
|
|
sheet.CreateFreezePane(SheetData.FreezePaneCols, SheetData.FreezePaneRows);
|
|
|
|
//设置栏目头和行内容的字体样式
|
|
ICellStyle cellHeadStyleDefault = work.CreateCellStyle();
|
|
ICellStyle cellStyleDefault = work.CreateCellStyle();
|
|
IFont fontHead = work.CreateFont();
|
|
fontHead.FontHeightInPoints = 9;
|
|
fontHead.FontName = "宋体";
|
|
cellHeadStyleDefault.SetFont(fontHead);
|
|
cellHeadStyleDefault.Alignment = HorizontalAlignment.Center;
|
|
cellHeadStyleDefault.FillForegroundColor = HSSFColor.Grey25Percent.Index;
|
|
cellHeadStyleDefault.FillPattern = FillPattern.SolidForeground;
|
|
IFont font = work.CreateFont();
|
|
font.FontHeightInPoints = 9;
|
|
font.FontName = "宋体";
|
|
cellStyleDefault.SetFont(font);
|
|
|
|
//用户指定了栏目格式的，按栏目创建好ICellStyle，方便下方循环单元格时直接使用
|
|
Dictionary<string, ICellStyle> dicColumnStyle = new Dictionary<string, ICellStyle>();
|
|
Dictionary<string, string> dicColumnFormula = new Dictionary<string, string>();
|
|
if (SheetData != null)
|
|
{
|
|
if (SheetData.ColumnStyle != null)
|
|
{
|
|
IDataFormat format = work.CreateDataFormat();//日期、数值类型的指定
|
|
foreach (string col in SheetData.ColumnStyle.Keys)
|
|
{
|
|
ICellStyle cellStyleEx = work.CreateCellStyle();
|
|
string sformula = "";
|
|
cellStyleEx.SetFont(font);
|
|
NpoiColumnStyle tCellStyle = SheetData.ColumnStyle[col];
|
|
if (tCellStyle != null && !tCellStyle.DataFormat.Equals(""))
|
|
{
|
|
cellStyleEx.DataFormat = format.GetFormat(tCellStyle.DataFormat);
|
|
sformula = tCellStyle.Formula;
|
|
}
|
|
dicColumnStyle.Add(col, cellStyleEx);
|
|
dicColumnFormula.Add(col, sformula);
|
|
sheet.SetDefaultColumnStyle(columnNameToIndex(col), cellStyleEx);
|
|
|
|
if (tCellStyle != null && tCellStyle.ColWidth != -1.0)
|
|
{
|
|
sheet.SetColumnWidth(columnNameToIndex(col), Pixel2ExcelWidth(tCellStyle.ColWidth));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (ColNameFirstRow)
|
|
{
|
|
IRow colrow = sheet.CreateRow(0);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
string sColumnName = ds.Tables[i].Columns[j].Caption.Trim();
|
|
if (sColumnName.Equals(""))
|
|
sColumnName = ds.Tables[i].Columns[j].ColumnName.Trim();
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
cell = colrow.CreateCell(j, CellType.String);//栏目行固定是String类型
|
|
cell.CellStyle = cellHeadStyleDefault;
|
|
//if ((SheetData.ColumnStyle != null) && (SheetData.ColumnStyle.ContainsKey(ColReference)))
|
|
//{
|
|
// NpoiColumnStyle tCellStyle = SheetData.ColumnStyle[ColReference];
|
|
// if (tCellStyle != null)
|
|
// {
|
|
// IDataFormat format = work.CreateDataFormat();//日期、数值类型的指定
|
|
// ICellStyle cellStyleNumberEx = cellHeadStyleDefault;
|
|
// cellStyleNumberEx.DataFormat = format.GetFormat(tCellStyle.DataFormat);
|
|
// cell.CellStyle = cellStyleNumberEx;
|
|
// }
|
|
//}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(sColumnName); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(sColumnName, out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(sColumnName, out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(sColumnName); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(sColumnName); break;
|
|
default: cell.SetCellValue(sColumnName); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = colrow.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellHeadStyleDefault;
|
|
cell.SetCellValue(sColumnName);
|
|
}
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new XSSFClientAnchor(j, 0, j + 1, 0 + 2, j + 1, 0, j + 2, 2));
|
|
comment.String = new XSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle=cellStyleColor;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
for (int k = 0; k < ds.Tables[i].Rows.Count; k++)
|
|
{
|
|
IRow row = sheet.CreateRow(k + 1);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(ColReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[ColReference];
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = row.CreateCell(j, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = row.CreateCell(j, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = row.CreateCell(j, CellType.String); break;
|
|
default: row.CreateCell(j, CellType.String); break;
|
|
}
|
|
if (dicColumnStyle != null && dicColumnStyle.ContainsKey(ColReference))
|
|
cell.CellStyle = dicColumnStyle[ColReference];
|
|
else
|
|
cell.CellStyle = cellStyleDefault;
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
default: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
}
|
|
|
|
//设置公式
|
|
if (dicColumnFormula != null && dicColumnFormula.ContainsKey(ColReference) && !dicColumnFormula[ColReference].Equals("") && cell.CellType == CellType.String)
|
|
{
|
|
cell.CellFormula = dicColumnFormula[ColReference];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = row.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellStyleDefault;
|
|
cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim());
|
|
}
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new XSSFClientAnchor(j, k, j + 1, k + 2, j + 1, k + 1, j + 2, k + 3));
|
|
comment.String = new XSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle = cellStyleColor;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int k = 0; k < ds.Tables[i].Rows.Count; k++)
|
|
{
|
|
IRow row = sheet.CreateRow(k);
|
|
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
|
|
{
|
|
ICell cell = null;
|
|
if (SheetData != null)
|
|
{
|
|
string ColReference = ColIndexToReference(j);
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(ColReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[ColReference];
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = row.CreateCell(j, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = row.CreateCell(j, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = row.CreateCell(j, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = row.CreateCell(j, CellType.String); break;
|
|
default: row.CreateCell(j, CellType.String); break;
|
|
}
|
|
if (dicColumnStyle != null && dicColumnStyle.ContainsKey(ColReference))
|
|
cell.CellStyle = dicColumnStyle[ColReference];
|
|
else
|
|
cell.CellStyle = cellStyleDefault;
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(ds.Tables[i].Rows[k][j].ToString().Trim(), out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
default: cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim()); break;
|
|
}
|
|
|
|
//设置公式
|
|
if (dicColumnFormula != null && dicColumnFormula.ContainsKey(ColReference) && !dicColumnFormula[ColReference].Equals("") && cell.CellType == CellType.String)
|
|
{
|
|
cell.CellFormula = dicColumnFormula[ColReference];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell = row.CreateCell(j, CellType.String);
|
|
cell.CellStyle = cellStyleDefault;
|
|
cell.SetCellValue(ds.Tables[i].Rows[k][j].ToString().Trim());
|
|
}
|
|
if (CellData != null)
|
|
{
|
|
string CellReference = GetCellReference(cell);
|
|
if ((CellData.CellComment != null) && (CellData.CellComment.ContainsKey(CellReference)))
|
|
{
|
|
string sComment = CellData.CellComment[CellReference];
|
|
if (!sComment.Equals(""))
|
|
{
|
|
IDrawing draw = sheet.CreateDrawingPatriarch();
|
|
IComment comment = draw.CreateCellComment(new XSSFClientAnchor(j, k, j + 1, k + 2, j + 1, k + 1, j + 2, k + 3));
|
|
comment.String = new XSSFRichTextString(sComment);
|
|
cell.CellComment = comment;
|
|
}
|
|
}
|
|
if ((CellData.CellFormula != null) && (CellData.CellFormula.ContainsKey(CellReference)))
|
|
{
|
|
string sFormula = CellData.CellFormula[CellReference];
|
|
if (!sFormula.Equals(""))
|
|
{
|
|
cell.CellFormula = sFormula;
|
|
}
|
|
}
|
|
if ((CellData.CellColor != null) && (CellData.CellColor.ContainsKey(CellReference)))
|
|
{
|
|
|
|
short sColorindex = CellData.CellColor[CellReference];
|
|
ICellStyle cellStyleColor = work.CreateCellStyle();
|
|
cellStyleColor.FillForegroundColor = sColorindex;
|
|
if ((CellData.CellFillPattern != null) && (CellData.CellFillPattern.ContainsKey(CellReference)))
|
|
{
|
|
|
|
FillPattern fill = (FillPattern)CellData.CellFillPattern[CellReference];
|
|
if (fill != null)
|
|
{
|
|
cellStyleColor.FillPattern = fill;
|
|
}
|
|
}
|
|
cell.CellStyle = cellStyleColor;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
using (FileStream fs = File.OpenWrite(filePath)) //打开一个xlsx文件，如果没有则自行创建，如果存在则在创建是不要打开该文件！
|
|
{
|
|
work.Write(fs); //向打开的这个xlsx文件中写入mySheet表并保存。
|
|
fs.Close();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message.Equals("") ? ex.InnerException.Message : ex.Message;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将业务数据写入xls文件中，返回临时文件全路径
|
|
/// </summary>
|
|
/// <param name="fileStream">xls文件流</param>
|
|
/// <param name="sSheetName">读取指定的Sheet页</param>
|
|
/// <param name="hasHeaderRow">首行是否为栏目行</param>
|
|
/// <param name="dsUpd">业务数据集</param>
|
|
/// <param name="dicMatchedCol">用于匹配行记录的栏目对应关系，格式：xls列坐标,业务数据集栏目 比如：A,BM_BMID</param>
|
|
/// <param name="dicUpdateCol">根据匹配到的行记录更新哪些栏目，用于存储栏目对应关系，格式：xls列坐标,业务数据集栏目 比如：B,BM_FZR</param>
|
|
/// <param name="SheetData">按dicUpdateCol进行更新数据时，指定栏目的数据类型</param>
|
|
/// <param name="bClearNotMatched">是否清空未匹配到的行记录的待更新栏目数据</param>
|
|
/// <param name="errorMessage">错误信息</param>
|
|
/// <returns>返回临时文件全路径</returns>
|
|
public static string UpdateExcel_NPOI(Stream fileStream, string sSheetName, bool hasHeaderRow, DataSet dsUpd, Dictionary<string, string> dicMatchedCol, Dictionary<string, string> dicUpdateCol,
|
|
NpoiSheetData SheetData, bool bClearNotMatched, ref string errorMessage)
|
|
{
|
|
if (sSheetName.Trim().Equals(""))
|
|
{
|
|
errorMessage = "未指定Sheet页";
|
|
return "";
|
|
}
|
|
if (dsUpd.Tables.Count == 0)
|
|
{
|
|
errorMessage = "传入的数据集为空";
|
|
return "";
|
|
}
|
|
|
|
//FileStream fs1 = File.OpenRead(filePath);
|
|
|
|
try
|
|
{
|
|
HSSFWorkbook wk = new HSSFWorkbook(fileStream);
|
|
|
|
ISheet sheet = wk.GetSheet(sSheetName);
|
|
if (sheet == null)
|
|
{
|
|
errorMessage = "未在电子表格中找到工作表：" + sSheetName;
|
|
return "";
|
|
}
|
|
|
|
string strSort = "";
|
|
int iSortCount = 0;
|
|
foreach (string sReference in dicMatchedCol.Keys)
|
|
{
|
|
if (!dicMatchedCol[sReference].Trim().Equals("") && dsUpd.Tables[0].Columns.Contains(dicMatchedCol[sReference].Trim())
|
|
&& !Convert.ToString("," + strSort).Contains("," + dicMatchedCol[sReference].Trim() + ","))
|
|
{
|
|
strSort += dicMatchedCol[sReference].Trim() + ",";
|
|
iSortCount++;
|
|
}
|
|
}
|
|
strSort = strSort.TrimEnd(',');
|
|
|
|
if (iSortCount != dicMatchedCol.Keys.Count)
|
|
{
|
|
errorMessage = "Excel栏目与数据集字段必须一对一匹配";
|
|
return "";
|
|
}
|
|
|
|
//单元格字体格式
|
|
ICellStyle cellStyleDefault = wk.CreateCellStyle();
|
|
IFont font = wk.CreateFont();
|
|
font.FontHeightInPoints = 9;
|
|
font.FontName = "宋体";
|
|
cellStyleDefault.SetFont(font);
|
|
|
|
DataView dvUpd = new DataView(dsUpd.Tables[0], "", strSort, DataViewRowState.CurrentRows);
|
|
|
|
int ifirstRow = sheet.FirstRowNum;
|
|
if (hasHeaderRow)//第一行是栏目行
|
|
ifirstRow = ifirstRow + 1;
|
|
for (int i = ifirstRow; i <= sheet.LastRowNum; i++)
|
|
{
|
|
object[] obj = new object[dicMatchedCol.Keys.Count];
|
|
int k = 0;
|
|
foreach (string sReference in dicMatchedCol.Keys)
|
|
{
|
|
ICell cell = sheet.GetRow(i).GetCell(columnNameToIndex(sReference));
|
|
obj[k] = GetCellValue(cell);
|
|
k++;
|
|
}
|
|
|
|
DataRowView[] rows = dvUpd.FindRows(obj);
|
|
if (rows.Length > 0)
|
|
{
|
|
foreach (DataRowView row in rows)
|
|
{
|
|
foreach (string sReference in dicUpdateCol.Keys)//缺dicUpdateCol的合法性校验
|
|
{
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData != null)
|
|
{
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(sReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[sReference];
|
|
}
|
|
}
|
|
|
|
int colIndex = columnNameToIndex(sReference);
|
|
ICell cell = sheet.GetRow(i).GetCell(colIndex);
|
|
if (cell == null)//没有动过的单元格取出来的cell是null
|
|
{
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
default: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
}
|
|
cell.CellStyle = cellStyleDefault;
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(row[dicUpdateCol[sReference]].ToString().Trim()); break;
|
|
case NpoiColumnType.Double:
|
|
double doubV = 0;
|
|
double.TryParse(row[dicUpdateCol[sReference]].ToString().Trim(), out doubV);
|
|
cell.SetCellValue(doubV);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
bool boolV = false;
|
|
bool.TryParse(row[dicUpdateCol[sReference]].ToString().Trim(), out boolV);
|
|
cell.SetCellValue(boolV);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(row[dicUpdateCol[sReference]].ToString().Trim()); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(row[dicUpdateCol[sReference]].ToString().Trim()); break;
|
|
default: cell.SetCellValue(row[dicUpdateCol[sReference]].ToString().Trim()); break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bClearNotMatched)
|
|
{
|
|
foreach (string sReference in dicUpdateCol.Keys)//缺dicUpdateCol的合法性校验
|
|
{
|
|
NpoiColumnType tCellType = NpoiColumnType.String;
|
|
if (SheetData != null)
|
|
{
|
|
if (SheetData.ColumnType != null && SheetData.ColumnType.ContainsKey(sReference))
|
|
{
|
|
tCellType = SheetData.ColumnType[sReference];
|
|
}
|
|
}
|
|
|
|
int colIndex = columnNameToIndex(sReference);
|
|
ICell cell = sheet.GetRow(i).GetCell(colIndex);
|
|
if (cell == null)//没有动过的单元格取出来的cell是null
|
|
{
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
case NpoiColumnType.Double: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.Numeric); break;
|
|
case NpoiColumnType.Boolean: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.Boolean); break;
|
|
case NpoiColumnType.DateTime: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
case NpoiColumnType.Date: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
default: cell = sheet.GetRow(i).CreateCell(colIndex, CellType.String); break;
|
|
}
|
|
cell.CellStyle = cellStyleDefault;
|
|
}
|
|
switch (tCellType)
|
|
{
|
|
case NpoiColumnType.String: cell.SetCellValue(""); break;
|
|
case NpoiColumnType.Double:
|
|
cell.SetCellValue(0);
|
|
break;
|
|
case NpoiColumnType.Boolean:
|
|
cell.SetCellValue(false);
|
|
break;
|
|
case NpoiColumnType.DateTime: cell.SetCellValue(""); break;
|
|
case NpoiColumnType.Date: cell.SetCellValue(""); break;
|
|
default: cell.SetCellValue(""); break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
string m_tmpFilePath = WorkDirectory.CombineTempPath(Guid.NewGuid().ToString() + ".xls");
|
|
|
|
using (FileStream fs = File.OpenWrite(m_tmpFilePath)) //打开一个xls文件，如果没有则自行创建，如果存在则在创建是不要打开该文件！
|
|
{
|
|
wk.ForceFormulaRecalculation = true;
|
|
wk.Write(fs); //向打开的这个xls文件中写入mySheet表并保存。
|
|
fs.Close();
|
|
return m_tmpFilePath;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
errorMessage = ex.Message;
|
|
return "";
|
|
}
|
|
//finally
|
|
//{
|
|
// fs1.Close();
|
|
//}
|
|
}
|
|
|
|
//获取cell的数据，并设置为对应的数据类型
|
|
public static object GetCellValue(ICell cell)
|
|
{
|
|
object value = null;
|
|
try
|
|
{
|
|
if (cell.CellType != CellType.Blank)
|
|
{
|
|
switch (cell.CellType)
|
|
{
|
|
case CellType.Numeric:
|
|
// Date comes here
|
|
if (DateUtil.IsCellDateFormatted(cell))
|
|
{
|
|
value = cell.DateCellValue;
|
|
}
|
|
else
|
|
{
|
|
// Numeric type
|
|
value = cell.NumericCellValue;
|
|
}
|
|
break;
|
|
case CellType.Boolean:
|
|
// Boolean type
|
|
value = cell.BooleanCellValue;
|
|
break;
|
|
case CellType.Formula:
|
|
value = cell.NumericCellValue; //公式返回Numeric
|
|
break;
|
|
default:
|
|
// String type
|
|
value = cell.StringCellValue;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
value = "";
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
//获取cell的坐标
|
|
public static string GetCellReference(ICell cell)
|
|
{
|
|
string cellReference = string.Empty;
|
|
if (cell != null)
|
|
cellReference = new CellReference(cell).FormatAsString();
|
|
return cellReference;
|
|
}
|
|
|
|
// DataSet的列序号转列坐标
|
|
public static string ColIndexToReference(int index)
|
|
{
|
|
string str = "";
|
|
bool bflag = false;
|
|
while (index > 25)
|
|
{
|
|
int j = index % 26;
|
|
str += Convert.ToChar(j + 'A');
|
|
index = index / 26;
|
|
bflag = true;
|
|
}
|
|
if (bflag)
|
|
str += Convert.ToChar(index - 1 + 'A');
|
|
else
|
|
str += Convert.ToChar(index + 'A');
|
|
|
|
Char[] c = str.ToCharArray();
|
|
Array.Reverse(c);
|
|
return new string(c);
|
|
}
|
|
|
|
//由Excel中的列坐标转为列序号
|
|
public static int columnNameToIndex(string columnName)
|
|
{
|
|
if (!Regex.IsMatch(columnName.ToUpper(), @"[A-Z]+")) { throw new Exception("invalid parameter"); }
|
|
|
|
int index = 0;
|
|
char[] chars = columnName.ToUpper().ToCharArray();
|
|
for (int i = 0; i < chars.Length; i++)
|
|
{
|
|
index += ((int)chars[i] - (int)'A' + 1) * (int)Math.Pow(26, chars.Length - i - 1);
|
|
}
|
|
return index - 1;
|
|
}
|
|
|
|
private static int Pixel2ExcelWidth(double pixelWidth)
|
|
{
|
|
return (int)(pixelWidth * 2 * 256 / 15);
|
|
}
|
|
}
|
|
}
|