Excel帮助类

Excel帮助类操作

public class ExcelHelper
{
/// <summary>
/// 将xls导入List
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="stream"></param>
/// <param name="errorstr"></param>
/// <returns></returns>
public static List<T> ImportExcelXLS<T>(Stream stream, out string errorstr)
{
return ConvertDataTable<T>(ImportExcelXLS(stream, out errorstr));
}

public static List<T> ImportExcelXLSX<T>(Stream stream, out string errorstr)
{
return ConvertDataTable<T>(ExcelToTableForXLSX(stream, out errorstr));
}

/// <summary>
/// 读取xls文件
/// </summary>
/// <param name="stream"></param>
/// <param name="errorstr"></param>
/// <returns></returns>
public static DataTable ImportExcelXLS(Stream stream, out string errorstr)
{
try
{
errorstr = string.Empty;
HSSFWorkbook hssfworkbook;
using (Stream memstream = new MemoryStream())
{
using (stream)
{

byte[] bytes = new byte[1024];
int readBtyes;
while ((readBtyes = stream.Read(bytes, 0, bytes.Length)) > 0)
{
memstream.Write(bytes, 0, readBtyes);
}
}
memstream.Position = 0;
hssfworkbook = new HSSFWorkbook(memstream);
}
NPOI.SS.UserModel.ISheet sheet = hssfworkbook.GetSheetAt(0);
NPOI.SS.UserModel.IRow rowHeader = sheet.GetRow(0);
System.Collections.IEnumerator rows = sheet.GetRowEnumerator();

DataTable dt = new DataTable();
for (int i = 0; i < rowHeader.PhysicalNumberOfCells; i++)
{
dt.Columns.Add(Convert.ToChar(((int)'A') + i).ToString());
}
while (rows.MoveNext())
{
HSSFRow row = (HSSFRow)rows.Current;
DataRow dr = dt.NewRow();
for (int i = 0; i < dt.Columns.Count; i++)
{
NPOI.SS.UserModel.ICell cell = row.GetCell(i);
if (cell == null)
{
dr[i] = null;
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Numeric)
{
//NPOI中数字和日期都是NUMERIC类型的，这里对其进行判断是否是日期类型
if (HSSFDateUtil.IsCellDateFormatted(cell)) //日期类型
{
dr[i] = cell.DateCellValue;
}
else //数值类型
{
dr[i] = cell.NumericCellValue;
}
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Blank) //空数据类型
{
dr[i] = "";
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Formula) //公式类型
{
HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(hssfworkbook);
dr[i] = eva.Evaluate(cell).StringValue;
}
else //其他类型都按字符串类型处理
{
dr[i] = cell.StringCellValue;
}
}
dt.Rows.Add(dr);
}
return dt;

}
catch (Exception ex)
{
errorstr = ex.ToString();
return null;
}
}

/// <summary>
/// 将Excel文件中的数据读出到DataTable中(xlsx)
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static DataTable ExcelToTableForXLSX(Stream stream, out string errorstr)
{

try
{
DataTable dt = new DataTable();
errorstr = string.Empty;
XSSFWorkbook xssfworkbook;
using (Stream memstream = new MemoryStream())
{

using (stream)
{

byte[] bytes = new byte[1024];
int readBtyes;
while ((readBtyes = stream.Read(bytes, 0, bytes.Length)) > 0)
{
memstream.Write(bytes, 0, readBtyes);
}
}
memstream.Position = 0;
xssfworkbook = new XSSFWorkbook(memstream);
}

NPOI.SS.UserModel.ISheet sheet = xssfworkbook.GetSheetAt(0);
NPOI.SS.UserModel.IRow rowHeader = sheet.GetRow(0);
System.Collections.IEnumerator rows = sheet.GetRowEnumerator();
for (int i = 0; i < rowHeader.PhysicalNumberOfCells; i++)
{
dt.Columns.Add(Convert.ToChar(((int)'A') + i).ToString());
}
while (rows.MoveNext())
{
XSSFRow row = (XSSFRow)rows.Current;
DataRow dr = dt.NewRow();
for (int i = 0; i < dt.Columns.Count; i++)
{
NPOI.SS.UserModel.ICell cell = row.GetCell(i);
if (cell == null)
{
dr[i] = null;
}
if (cell == null)
{
dr[i] = null;
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Numeric)
{
//NPOI中数字和日期都是NUMERIC类型的，这里对其进行判断是否是日期类型
if (HSSFDateUtil.IsCellDateFormatted(cell)) //日期类型
{
dr[i] = cell.DateCellValue;
}
else //数值类型
{
dr[i] = cell.NumericCellValue;
}
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Blank) //空数据类型
{
dr[i] = "";
}
else if (cell.CellType == NPOI.SS.UserModel.CellType.Formula) //公式类型
{
HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(xssfworkbook);
dr[i] = eva.Evaluate(cell).StringValue;
}
else //其他类型都按字符串类型处理
{
dr[i] = cell.StringCellValue;
}
}
dt.Rows.Add(dr);
}
return dt;
}
catch (Exception ex)
{
errorstr = ex.ToString();
return null;
}
}

/// <summary>
/// 获取单元格类型(xlsx)
/// </summary>
/// <param name="cell"></param>
/// <returns></returns>
private static object GetValueTypeForXLSX(XSSFCell cell)
{
if (cell == null)
return null;
switch (cell.CellType)
{
case CellType.Blank: //BLANK:
return null;
case CellType.Boolean: //BOOLEAN:
return cell.BooleanCellValue;
case CellType.Numeric: //NUMERIC:
return cell.NumericCellValue;
case CellType.String: //STRING:
return cell.StringCellValue;
case CellType.Error: //ERROR:
return cell.ErrorCellValue;
case CellType.Formula: //FORMULA:
default:
return "=" + cell.CellFormula;
}
}

/// <summary>
/// 将DataTable转换List
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dt"></param>
/// <returns></returns>
private static List<T> ConvertDataTable<T>(DataTable dt)
{

List<T> data = new List<T>();
for (int i = 0; i < dt.Rows.Count; i++)
{
T item = GetItem<T>(dt.Rows[i]);
data.Add(item);
}
return data;
}

/// <summary>
/// 读取Data转换List
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dr"></param>
/// <returns></returns>
private static T GetItem<T>(DataRow dr)
{
Type temp = typeof(T);
T obj = Activator.CreateInstance<T>();
foreach (DataColumn column in dr.Table.Columns)
{
foreach (PropertyInfo pro in temp.GetProperties())
{
if (pro.GetCustomAttribute<ExcelAttribute>() != null && pro.GetCustomAttribute<ExcelAttribute>().ColumnName == dr.Table.Rows[0][column].ToString())
{
pro.SetValue(obj, Convert.ChangeType(dr[column.ColumnName], pro.PropertyType), null);
}
}
}
return obj;
}

public static MemoryStream ExportByList<T>(List<T> dtList, string strHeaderText, string loginName, out string errorstr, int sheetSize = 0xfde8)
{
return Export(ToDataTable<T>(dtList), strHeaderText, loginName, out errorstr, sheetSize);
}

private static DataTable ToDataTable<T>(List<T> list)
{
Type type = typeof(T);
using (DataTable table = new DataTable())
{
Type propertyType;
Type type3;
ExcelAttribute customAttribute;
string str;
DataRow row = table.NewRow();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo info in properties)
{
if (info.GetCustomAttribute<ExcelAttribute>() != null)
{
propertyType = info.PropertyType;
type3 = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
customAttribute = info.GetCustomAttribute<ExcelAttribute>();
str = customAttribute.ColumnName + (string.IsNullOrEmpty(customAttribute.Format) ? "" : ("@$@" + customAttribute.Format));
table.Columns.Add(str, type3);
}
}
for (int i = 0; i < list.Count; i++)
{
DataRow row2 = table.NewRow();
foreach (PropertyInfo info in properties)
{
propertyType = info.PropertyType;
type3 = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
customAttribute = info.GetCustomAttribute<ExcelAttribute>();
if (customAttribute != null)
{
str = customAttribute.ColumnName + (string.IsNullOrEmpty(customAttribute.Format) ? "" : ("@$@" + customAttribute.Format));
row2[str] = info.GetValue(list[i], null) ?? DBNull.Value;
}
}
table.Rows.Add(row2);
}
return table;
}
}

public static MemoryStream Export(DataTable dtSource, string strHeaderText, string loginName, out string errorstr, int sheetSize = 0xfde8)
{
MemoryStream stream2;
errorstr = "";
try
{
ISheet sheet;
string realColName;
int num2;
int num3;
HSSFWorkbook workbook = new HSSFWorkbook();
List<ISheet> list = new List<ISheet>();
for (int i = dtSource.Rows.Count; i > 0; i -= sheetSize)
{
sheet = workbook.CreateSheet();
list.Add(sheet);
}
if (list.Count == 0)
{
sheet = workbook.CreateSheet();
list.Add(sheet);
}
DocumentSummaryInformation information = PropertySetFactory.CreateDocumentSummaryInformation();
information.Company = "NPOI";
workbook.DocumentSummaryInformation = information;
SummaryInformation information2 = PropertySetFactory.CreateSummaryInformation();
information2.Author = "安鲜达";
information2.ApplicationName = "安鲜达";
information2.LastAuthor = loginName;
information2.Comments = loginName;
information2.Title = "安鲜达";
information2.Subject = "安鲜达表格";
information2.CreateDateTime = new DateTime?(DateTime.Now);
workbook.SummaryInformation = information2;
int[] numArray = new int[dtSource.Columns.Count];
foreach (DataColumn column in dtSource.Columns)
{
realColName = GetRealColName(column.ColumnName);
numArray[column.Ordinal] = Encoding.GetEncoding(0x3a8).GetBytes(realColName).Length;
}
for (num2 = 0; num2 < dtSource.Rows.Count; num2++)
{
num3 = 0;
while (num3 < dtSource.Columns.Count)
{
int length = Encoding.GetEncoding(0x3a8).GetBytes(dtSource.Rows[num2][num3].ToString()).Length;
if (length > numArray[num3])
{
numArray[num3] = length;
}
num3++;
}
}
ICellStyle style = workbook.CreateCellStyle();
style.Alignment = HorizontalAlignment.Center;
IFont font = workbook.CreateFont();
font.FontHeightInPoints = 10;
font.Boldweight = 700;
style.SetFont(font);
for (num2 = 0; num2 < list.Count; num2++)
{
IRow row = list[num2].CreateRow(0);
foreach (DataColumn column2 in dtSource.Columns)
{
realColName = GetRealColName(column2.ColumnName);
row.CreateCell(column2.Ordinal).SetCellValue(realColName);
row.GetCell(column2.Ordinal).CellStyle = style;
int num5 = numArray[column2.Ordinal] + 1;
if (num5 > 0xff)
{
num5 = 0xff;
}
list[num2].SetColumnWidth(column2.Ordinal, num5 * 0x100);
}
}
List<ICellStyle> list2 = new List<ICellStyle>();
for (num2 = 0; num2 < dtSource.Columns.Count; num2++)
{
string format = GetFormat(dtSource.Columns[num2].ColumnName);
if (string.IsNullOrEmpty(format))
{
list2.Add(null);
}
else
{
ICellStyle item = workbook.CreateCellStyle();
item.DataFormat = workbook.CreateDataFormat().GetFormat(format);
list2.Add(item);
}
}
int rownum = 1;
for (num2 = 0; num2 < list.Count; num2++)
{
rownum = 1;
int num7 = num2 * sheetSize;
int num8 = (((num2 + 1) * sheetSize) > dtSource.Rows.Count) ? dtSource.Rows.Count : ((num2 + 1) * sheetSize);
for (num3 = num7; num3 < num8; num3++)
{
DataRow row2 = dtSource.Rows[num3];
IRow row3 = list[num2].CreateRow(rownum);
for (int j = 0; j < dtSource.Columns.Count; j++)
{
DateTime minValue;
ICell cell = row3.CreateCell(dtSource.Columns[j].Ordinal);
string str3 = (row2[dtSource.Columns[j]] == null) ? string.Empty : row2[dtSource.Columns[j]].ToString().Trim();
switch (dtSource.Columns[j].DataType.ToString())
{
case "System.String":
{
cell.SetCellValue(str3);
continue;
}
case "System.DateTime":
{
minValue = DateTime.MinValue;
DateTime.TryParse(str3, out minValue);
if (list2[j] == null)
{
break;
}
cell.SetCellValue(minValue);
cell.CellStyle = list2[j];
continue;
}
case "System.Boolean":
{
bool result = false;
bool.TryParse(str3, out result);
cell.SetCellValue(result);
continue;
}
case "System.Int16":
case "System.Int32":
case "System.Int64":
case "System.Byte":
{
int num10 = 0;
int.TryParse(str3, out num10);
cell.SetCellValue((double)num10);
if (list2[j] != null)
{
cell.CellStyle = list2[j];
}
continue;
}
case "System.Decimal":
case "System.Double":
{
double num11 = 0.0;
double.TryParse(str3, out num11);
cell.SetCellValue(num11);
if (list2[j] != null)
{
cell.CellStyle = list2[j];
}
continue;
}
case "System.DBNull":
{
cell.SetCellValue("");
continue;
}
default:
goto Label_06B4;
}
cell.SetCellValue(minValue.ToString("yyyy/MM/dd HH:mm:ss"));
continue;
Label_06B4:
cell.SetCellValue("");
}
rownum++;
}
}
using (MemoryStream stream = new MemoryStream())
{
workbook.Write(stream);
stream.Flush();
stream.Position = 0L;
stream2 = stream;
}
}
catch (Exception exception)
{
errorstr = JsonConvert.SerializeObject(exception);
stream2 = null;
}
return stream2;
}

private static string GetFormat(string oriName)
{
if (string.IsNullOrEmpty(oriName))
{
return null;
}
int index = oriName.IndexOf("@$@");
if (index == -1)
{
return null;
}
return oriName.Substring(index + "@$@".Length).Trim();
}

private static string GetRealColName(string oriName)
{
if (string.IsNullOrEmpty(oriName))
{
return oriName;
}
int index = oriName.IndexOf("@$@");
if (index == -1)
{
return oriName;
}
return oriName.Substring(0, index);
}

public static List<T> Import<T>(Stream stream, out string errorStr)
{
return ConvertDataTable<T>(Import(stream, out errorStr));
}
public static DataTable Import(Stream stream, out string errorStr)
{
try
{
errorStr = "";
HSSFWorkbook workbook = new HSSFWorkbook(stream);
ISheet sheetAt = workbook.GetSheetAt(0);
IRow row = sheetAt.GetRow(0);
IEnumerator rowEnumerator = sheetAt.GetRowEnumerator();
DataTable table = new DataTable();
for (int i = 0; i < row.PhysicalNumberOfCells; i++)
{
table.Columns.Add(Convert.ToChar((int)(0x41 + i)).ToString());
}
while (rowEnumerator.MoveNext())
{
HSSFRow current = (HSSFRow)rowEnumerator.Current;
DataRow row3 = table.NewRow();
for (int j = 0; j < table.Columns.Count; j++)
{
ICell cell = current.GetCell(j);
if (cell == null)
{
row3[j] = null;
}
else if (cell.CellType == CellType.Numeric)
{
if (DateUtil.IsCellDateFormatted(cell))
{
row3[j] = cell.DateCellValue;
}
else
{
row3[j] = cell.NumericCellValue;
}
}
else if (cell.CellType == CellType.Blank)
{
row3[j] = "";
}
else if (cell.CellType == CellType.Formula)
{
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);
row3[j] = evaluator.Evaluate(cell).StringValue;
}
else
{
row3[j] = cell.StringCellValue;
}
}
table.Rows.Add(row3);
}
return table;
}
catch (Exception exception)
{
errorStr = JsonConvert.SerializeObject(exception);
return null;
}
}
}