使用NPOI导出Excel引发异常（IsReadOnly = “book.IsReadOnly”引发了类型“System.NotImplementedException”的异常）

前言：

本人调式npoi导入、导出试用成功后，引入到项目中，导入完美运行，但是导出怎么样都看不到现在的页面，而且浏览器和后台都没有报任务错误，让人好事纳闷，后来去调式，发现在除了一个IsReadOnly = “book.IsReadOnly”引发了类型“System.NotImplementedException”的异常）。最开始的怀疑是这里问题，然后去调式环境看也是存在的，然后就自然想到的前端问题。最后果然是前端出了问题，在导出的点击函数里写了异步ajax蠢死了，后来异步ajax改成  完美导出。

NPOI 常用本版本下载：

http://download.csdn.net/detail/whk311/6465879

mynpoi导入导出封装：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NPOI.SS.UserModel;
using NPOI.HSSF.UserModel;
using NPOI.HSSF.Util;
using System.IO;
using NPOI.HPSF;
using System.Web;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using System.Collections;
using NPOI.SS.Util;
using System.Drawing;
using System.Data;
using System.Reflection;
using System.Linq.Expressions;
using GTJ.Utility.MyNPOI;
 
namespace MyNPOI.Excel
{
    internal class ExcelHelper
    {
        #region "构造函数"
        internal ExcelHelper() { }
        #endregion
 
        #region "私有字段"
        /// <summary>
        /// 自定义颜色
        /// </summary>
        HSSFPalette XlPalette = null;
        /// <summary>
        /// 要导出的excel对象
        /// </summary>
        private HSSFWorkbook workbook = null;
        /// <summary>
        /// 要导出的excel对象属性
        /// </summary>
        private HSSFWorkbook Workbook
        {
            get
            {
                if (workbook == null)
                {
                    workbook = new HSSFWorkbook();
                }
                return workbook;
            }
            set { workbook = value; }
        }
        /// <summary>
        /// 要导出的excel对象中的一个表
        /// </summary>
        private ISheet sheet = null;
        /// <summary>
        /// 导出的内容部分的样式
        /// </summary>
        HSSFCellStyle cellStyle = null;
        /// <summary>
        /// 表头行数
        /// </summary>
        int rowHeadNum = ;
        /// <summary>
        /// 行数，方便内容正确在行插入
        /// </summary>
        private List<IRow> rowList = new List<IRow>();
 
        private List<GroupClass> gCell = null;
        private List<GroupClass> GCell
        {
            get { return gCell; }
            set { gCell = value; }
        }
 
        /// <summary>
        /// 整个表格border样式，默认solid
        /// </summary>
        private BorderStyle wholeBorderStyle = BorderStyle.Thin;
        private BorderStyle WholeBorderStyle
        {
            get { return wholeBorderStyle; }
            set { wholeBorderStyle = value; }
        }
        /// <summary>
        /// 整个表格border颜色，默认黑色
        /// </summary>
        private short wholeBorderColor = HSSFColor.Black.Index;
        public short WholeBorderColor
        {
            get { return wholeBorderColor; }
            set { wholeBorderColor = value; }
        }
        /// <summary>
        /// 表头单元格字体是否加粗
        /// </summary>
        private short headFontWeight = (short)FontBoldWeight.Bold;
        /// <summary>
        /// 表头单元格字体是否加粗
        /// </summary>
        public short HeadFontWeight
        {
            get { return headFontWeight; }
            set { headFontWeight = value; }
        }
 
        #endregion
 
        /// <summary>
        /// 创建表头
        /// </summary>
        /// <param name="json">类似json的字符串</param>
        internal void SetHead(string json,List<GroupClass> group,int column)
        {
            Root T =Utility.JsonUtility.DecodeObject<Root>(json);
            //确定表头行数
            if (group != null && column > -)
            {
                     int headRow = T.root.rowspan.Value;
                     int indexs = headRow;
                    foreach (var item in group)
                    {
                        item.column = column;
                        if (indexs == headRow)
                        {
                            item.index = headRow;
                        }
                        else
                        {
                            item.index = indexs;
                        }
                        indexs = item.index.Value + item.groupCount.Value;
                    }
                    SetGroupCell(group);
            }
            if (sheet == null)
            {
                sheet = Workbook.CreateSheet(T.root.sheetname);
            }
            sheet.DisplayGridlines = true;
            if (T.root.defaultwidth.HasValue)
            {
                //设置表格默认宽高
                sheet.DefaultColumnWidth = T.root.defaultwidth.Value; //
            }
            if (T.root.defaultheight.HasValue)
            {
                //设置表格默认行高
                sheet.DefaultRowHeight = (short)T.root.defaultheight.Value; //
            }
            if (!string.IsNullOrEmpty(T.root.borderstyle))
            {
                string bStyle = T.root.borderstyle.Trim();
                if (!string.IsNullOrEmpty(bStyle))
                {
                    switch (bStyle)
                    {
                        case "none":
                            WholeBorderStyle = BorderStyle.None;
                            break;
                        case "solid":
                            WholeBorderStyle = BorderStyle.Thin;
                            break;
                        case "dashed":
                            WholeBorderStyle = BorderStyle.Dashed;
                            break;
                        case "dotted":
                            WholeBorderStyle = BorderStyle.Dotted;
                            break;
                        case "double":
                            WholeBorderStyle = BorderStyle.Double;
                            break;
                        default:
                            WholeBorderStyle = BorderStyle.Thin;
                            break;
                    }
                }
            }
            XlPalette = Workbook.GetCustomPalette();
            if (!string.IsNullOrEmpty(T.root.bordercolor))
            {
                Color co = ColorTranslator.FromHtml(T.root.bordercolor);
                XlPalette.SetColorAtIndex(HSSFColor.Plum.Index, (byte)co.R, (byte)co.G, (byte)co.B);
                WholeBorderColor = NPOI.HSSF.Util.HSSFColor.Plum.Index;//这句代码根据16进制不起作用，起到颜色初始化
            }
 
            int rowN = Convert.ToInt32(T.root.rowspan);
            rowHeadNum = rowN ;
            //创建行
            for (int i = ; i < rowN; i++)
            {
                IRow temp = sheet.CreateRow(i);
                rowList.Add(temp);
 
            }
            //合并单元格
            //填充内容
            for (int i = ; i < T.root.head.Count; i++)
            {
                //读取最重要的区域,0=fromRow,1=toRow,2=fromColumn,3=toColumn
                AttributeList al = T.root.head[i];
                int[] c = al.cellregion.Split(',').ToIntArray();
                if (c[] < c[] || c[] < c[])   //例如1,1,2,2 第二行中的第3列,例如1,1,2,7 第二行中的(第3列到8列),合并列
                {
                    CellRangeAddress cellr = new CellRangeAddress(c[], c[], c[], c[]);
                    sheet.AddMergedRegion(cellr);
                    //设置边框
                    ((HSSFSheet)sheet).SetEnclosedBorderOfRegion(cellr, WholeBorderStyle, WholeBorderColor);
                }
            }
            //填充内容
            for (int i = ; i < T.root.head.Count; i++)
            {
                //读取最重要的区域,0=fromRow,1=toRow,2=fromColumn,3=toColumn
                AttributeList al = T.root.head[i];
                int[] c = al.cellregion.Split(',').ToIntArray();
                //计算title要插入的位置的索引
                int txtIndex = -;
                int txtRow = -;
 
                if ((c[] == c[] && c[] == c[]) || (c[] == c[] && c[] < c[]))
                { //例如1,1,2,2 第二行中的第3列,例如1,1,2,7 第二行中的(第3列到8列)
                    txtIndex = c[];
                    txtRow = c[];
                    ICell cell1 = rowList[txtRow].CreateCell(txtIndex);
 
                    //设置单元格的高度
                    if (!T.root.defaultheight.HasValue&& al.height.HasValue)
                    {
                        rowList[txtRow].HeightInPoints = (short)al.height.Value ;
                    }
                    SetHeadCellBold(al);
                    cell1.SetCellValue(al.title);
                    cell1.CellStyle = SetCellStyle(al);
 
                }
                if (c[] < c[] && c[] == c[]) //合并c[0]到c[1]行 ，列没变 ，   'cellregion':'0,1,1,1',
                {
                    txtIndex = c[];
                    txtRow = c[];
                    ICell cell1 = rowList[txtRow].CreateCell(txtIndex);
                    //设置单元格的高度
                    if (!T.root.defaultheight.HasValue && al.height.HasValue)
                    {
                        rowList[txtRow].Height = (short)(al.height.Value * );
                    }
                    SetHeadCellBold(al);
                    cell1.SetCellValue(al.title);
                    cell1.CellStyle = SetCellStyle(al);
                }
                if (c[] < c[] && c[] < c[]) //合并c[0]到c[1]行 ，列没变 ，   'cellregion':'4,5,2,4',
                {
                    txtIndex = c[];
                    txtRow = c[];
                    ICell cell1 = rowList[txtRow].CreateCell(txtIndex);
                    SetHeadCellBold(al);
                    //设置单元格的高度
                    if (!T.root.defaultheight.HasValue && al.height.HasValue)
                    {
                        rowList[txtRow].Height = (short)(al.height.Value * );
                    }
                    cell1.SetCellValue(al.title);
                    cell1.CellStyle = SetCellStyle(al);
                }
 
                //设置单元格的宽度
                if (!T.root.defaultwidth.HasValue && al.width.HasValue)
                {
                    sheet.SetColumnWidth(i, al.width.Value * );
                }
            }
 
        }
        /// <summary>
        /// 设置表头单元格字体是否加粗，默认加粗
        /// </summary>
        /// <param name="al"></param>
        private void SetHeadCellBold(AttributeList al)
        {
            if (string.IsNullOrEmpty(al.fontweight)) {
                HeadFontWeight = (short)FontBoldWeight.Bold;
            }
            else
            {
                switch (al.fontweight)
                {
                    case "bold":
                        HeadFontWeight = (short)FontBoldWeight.Bold;
                        break;
                    case "none":
                        HeadFontWeight = (short)FontBoldWeight.None;
                        break;
                    case "normal":
                        HeadFontWeight = (short)FontBoldWeight.Normal;
                        break;
                    default:
                        HeadFontWeight = (short)FontBoldWeight.Bold;
                        break;
                }
            }
        }
 
        /// <summary>
        /// web导出excel
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="list">导出的列表对象</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="titles">标题</param>
        /// <param name="fieldFuncs">字段委托，如果不传则T的全部属性</param>
        internal void ExportToWeb<T>(List<T> list, string fileName, string[] titles, string headJson, params Func<T, string>[] fieldFuncs)
        {
            ///创建表头
            SetHead(headJson,null,-);
            ///转换数据源
            DataTable dtSource = list.ToDataTable(titles, fieldFuncs);
            ///开始导出
            WebCommonExport(dtSource, fileName);
            System.GC.Collect();
        }
        /// <summary>
        /// web导出excel
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="list">导出的列表对象</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="titles">标题</param>
        /// <param name="fieldFuncs">字段委托，如果不传则T的全部属性</param>
        internal void ExportToWeb<T>(List<T> list, string fileName, string[] titles, string headJson,List<GroupClass> group,int groupColumn,params Func<T, string>[] fieldFuncs)
        {
            ///创建表头
            SetHead(headJson, group,groupColumn);
            ///转换数据源
            DataTable dtSource = list.ToDataTable(titles, fieldFuncs);
            ///开始导出
            WebCommonExport(dtSource, fileName);
            System.GC.Collect();
        }
 
        /// <summary>
        /// 保存到本地
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="list">导出的列表对象</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="titles">标题</param>
        /// <param name="fieldFuncs">字段委托，如果不传则T的全部属性</param>
        internal void ExportToLocal<T>(List<T> list, string fileName, string[] titles, string headJson, params Func<T, string>[] fieldFuncs)
        {
            ///创建表头
            SetHead(headJson, null, -);
            ///转换数据源
            DataTable dtSource = list.ToDataTable(titles, fieldFuncs);
            ///开始导出
            LocalCommonExport(dtSource, fileName);
            System.GC.Collect();
        }
        /// <summary>
        /// 保存到本地
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="list">导出的列表对象</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="titles">标题</param>
        /// <param name="fieldFuncs">字段委托，如果不传则T的全部属性</param>
        internal void ExportToLocal<T>(List<T> list, string fileName, string[] titles, string headJson, List<GroupClass> group, int groupColumn, params Func<T, string>[] fieldFuncs)
        {
            ///创建表头
            SetHead(headJson, group,groupColumn);
            ///转换数据源
            DataTable dtSource = list.ToDataTable(titles, fieldFuncs);
            ///开始导出
            LocalCommonExport(dtSource, fileName);
            System.GC.Collect();
        }
        /// DataTable导出到Excel的MemoryStream,#CommonExport,全部都是字符串处理
        /// </summary>
        /// <param name="dtSource">源DataTable</param>
        /// <param name="strHeaderText">表头文本</param>
        internal void WebCommonExport(DataTable dtSource, string fileName)
        {
            BeforeExport(dtSource);
            //转换好后开始提供下载
            Workbook.ExportToWeb(fileName);
        }
 
        /// DataTable导出到Excel的MemoryStream,#CommonExport,全部都是字符串处理
        /// </summary>
        /// <param name="dtSource">源DataTable</param>
        /// <param name="fileName">文件存储路径</param>
        ///
        internal void LocalCommonExport(DataTable dtSource, string fileName)
        {
            BeforeExport(dtSource);
            //转换好后开始保存本地
            Workbook.ExportToLocal(fileName);
        }
 
        /// <summary>
        /// 整合数据
        /// </summary>
        /// <param name="dtSource"></param>
        private void BeforeExport(DataTable dtSource)
        {
            HSSFCellStyle dateStyle = (HSSFCellStyle)Workbook.CreateCellStyle();
            cellStyle = SetContentFormat(, );
            //取得列宽
            int[] arrColWidth = new int[dtSource.Columns.Count];
            foreach (DataColumn item in dtSource.Columns)
            {
                arrColWidth[item.Ordinal] = Encoding.GetEncoding().GetBytes(item.ColumnName.ToString()).Length;
            }
            for (int i = ; i < dtSource.Rows.Count; i++)
            {
                for (int j = ; j < dtSource.Columns.Count; j++)
                {
                    int intTemp = Encoding.GetEncoding().GetBytes(dtSource.Rows[i][j].ToString()).Length;
                    if (intTemp > arrColWidth[j])
                    {
                        arrColWidth[j] = intTemp;
                    }
                }
            }
            int rowIndex = rowList.Count();
            dtSource.Rows.RemoveAt(); //移除第一行，因为有表头了
 
            foreach (DataRow row in dtSource.Rows)
            {
                IRow dataRow = sheet.CreateRow(rowIndex);
                foreach (DataColumn column in dtSource.Columns)
                {
                    ICell newCell = dataRow.CreateCell(column.Ordinal);
                    newCell.CellStyle = cellStyle;
                    string drValue = row[column].ToString();
                    newCell.SetCellValue(drValue);
 
                }
                rowIndex++;
            }
 
            try
            {
                int temp = ;
                if (GCell != null && dtSource.Rows.Count > )
                {
                    foreach (GroupClass gCell in GCell)
                    {
 
                        IRow row = sheet.GetRow(gCell.index.Value);//获取工作表第一行
                        ICell cell = row.GetCell(gCell.column);//获取行的第COLUMN列
                        string cellValue = cell.ToString();//获取列的值
                        //如果设置了分组，目前只能一种
                        temp=gCell.index.Value+gCell.groupCount.Value-;
                        CellRangeAddress cellr = new CellRangeAddress(gCell.index.Value, temp, gCell.column, gCell.column);
                        sheet.AddMergedRegion(cellr);
                        //设置边框
                        ((HSSFSheet)sheet).SetEnclosedBorderOfRegion(cellr, WholeBorderStyle, WholeBorderColor);
                        ICell ce = row.CreateCell(gCell.column);
                        ce.CellStyle = cellStyle;
                        ce.SetCellValue(cellValue);
                    }
                }
            }
            catch
            {
                throw new Exception("GroupCell某些属性可能为空了！");
            }
 
        }
 
        #region 辅助帮助，设置样式和 转换颜色
        static bool cellColorBug = true; //关于NPOI自定义颜色设置有个bug，这个可以保证第一次单元格设置不会始终黑色
        /// <summary>
        /// 设置单元格基本样式
        /// </summary>
        /// <param name="al"></param>
        private HSSFCellStyle SetCellStyle(AttributeList al)
        {
            HSSFCellStyle headStyle = (HSSFCellStyle)Workbook.CreateCellStyle();
            XlPalette = Workbook.GetCustomPalette();
            headStyle.Alignment = string.IsNullOrEmpty(al.align) ? HorizontalAlignment.Center : al.align.ToHorAlign(); //默认水平居中
            headStyle.VerticalAlignment = string.IsNullOrEmpty(al.valign) ? VerticalAlignment.Center : al.valign.ToVerAlign();//垂直居中
            headStyle.FillPattern = FillPattern.SolidForeground; //默认填充整个背景颜色
            bool forc = string.IsNullOrEmpty(al.bgcolor); //是否有背景颜色
            if (forc)
            {
                headStyle.FillForegroundColor = HSSFColor.Grey25Percent.Index; //默认灰色
            }
            else
            {
                headStyle.FillForegroundColor = GetColorIndex(Workbook, al.bgcolor);//这句代码根据16进制不起作用，起到颜色初始化
                if (cellColorBug)
                {
                    Color co = ColorTranslator.FromHtml(al.bgcolor);
                    XlPalette.SetColorAtIndex(HSSFColor.Pink.Index, (byte)co.R, (byte)co.G, (byte)co.B);
                    headStyle.FillForegroundColor = NPOI.HSSF.Util.HSSFColor.Pink.Index;
                    cellColorBug = false;
                }
            }
 
            //设置单元格border
            headStyle.BorderRight = headStyle.BorderLeft = headStyle.BorderBottom = headStyle.BorderTop = WholeBorderStyle;
            headStyle.BottomBorderColor = headStyle.RightBorderColor = headStyle.LeftBorderColor = headStyle.TopBorderColor = WholeBorderColor;
            bool fontc = string.IsNullOrEmpty(al.fontcolor); //是否有字体颜色
            //设置单元格字体
            HSSFFont font = (HSSFFont)Workbook.CreateFont();
            if (fontc)
            {
                font.Color = ; //默认黑色
            }
            else
            {
                font.Color = GetColorIndex(Workbook, al.fontcolor);//这句代码根据16进制不起作用，起到颜色初始化
                if (cellColorBug)
                {
                    Color co = ColorTranslator.FromHtml(al.fontcolor);
                    XlPalette.SetColorAtIndex(HSSFColor.Pink.Index, (byte)co.R, (byte)co.G, (byte)co.B);
                    font.Color = NPOI.HSSF.Util.HSSFColor.Pink.Index;
                    cellColorBug = false;
                }
            }
 
            font.FontHeightInPoints = al.fontsize ?? ; //设置字体大小
            font.Boldweight =HeadFontWeight;
            font.FontName = string.IsNullOrWhiteSpace(al.fontName) ? "宋体" : al.fontName;//设置字体为宋体
            font.IsItalic = al.IsItalic.HasValue && al.IsItalic.Value ? true : false;//是否是斜体
            font.IsStrikeout = al.IsStrikeout.HasValue && al.IsStrikeout.Value ? true : false;//是否有中间线
            font.Underline = al.Underline.HasValue && al.Underline.Value ? FontUnderlineType.Single :FontUnderlineType.None;//设置下划线
            headStyle.SetFont(font);
            return headStyle;
        }
 
        /// <summary>
        /// 根据十六进制颜色获得颜色索引
        /// </summary>
        /// <param name="workbook"></param>
        /// <param name="color"></param>
        /// <returns></returns>
        private short GetColorIndex(HSSFWorkbook workbook, string color)
        {
            Color co = ColorTranslator.FromHtml(color);
 
            return GetXLColour(workbook, co);
        }
 
        //获得excel中的颜色索引
        private short GetXLColour(HSSFWorkbook workbook, System.Drawing.Color SystemColour)
        {
            short s = ;
            HSSFPalette XlPalette = workbook.GetCustomPalette();
            HSSFColor XlColour = XlPalette.FindColor(SystemColour.R, SystemColour.G, SystemColour.B);
            //if (XlColour == null)
            //{
            //    if (NPOI.HSSF.Record.PaletteRecord.STANDARD_PALETTE_SIZE < 255)
            //    {
            //        if (NPOI.HSSF.Record.PaletteRecord.STANDARD_PALETTE_SIZE < 64)
            //        {
            //            NPOI.HSSF.Record.PaletteRecord.STANDARD_PALETTE_SIZE = 64;
            //            NPOI.HSSF.Record.PaletteRecord.STANDARD_PALETTE_SIZE += 1;
            //            XlColour = XlPalette.AddColor(SystemColour.R, SystemColour.G, SystemColour.B);
            //        }
            //        else
            //        {
            //            XlColour = XlPalette.FindSimilarColor(SystemColour.R, SystemColour.G, SystemColour.B);
            //        }
 
            //        s = XlColour.Indexed;
            //    }
 
            //}
            //else
            //    s = XlColour.Indexed;
 
            return s;
        }
 
        #endregion
 
        #region 设置excel文件基本属性
        /// <summary>
        /// 文件基本属性
        /// </summary>
        /// <param name="company">公司名称，默认 慧择网</param>
        /// <param name="author">作者信息，默认 慧择</param>
        /// <param name="ApplicationName">创建程序信息</param>
        /// <param name="LastAuthor">xls文件最后保存者信息</param>
        /// <param name="Comments">填加xls文件作者信息，备注</param>
        /// <param name="title">填加xls文件标题信息</param>
        /// <param name="Subject">填加文件主题信息</param>
        /// <returns>一个初始化的Excel Workbook对象</returns>
        internal void SetWorkbook(ExcelProperty ep)
        {
            #region 右击文件 属性信息
            DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
            ///公司
            dsi.Company = ep.Company;
            dsi.Manager = ep.Manager;
            dsi.Category = ep.Catagory;
            Workbook.DocumentSummaryInformation = dsi;
            SummaryInformation si = PropertySetFactory.CreateSummaryInformation();
            si.Author = ep.Author; //填加xls文件作者信息
            si.ApplicationName = ep.ApplicationName; //填加xls文件创建程序信息
            si.LastAuthor = ep.LastAuthor; //填加xls文件最后保存者信息
            si.Comments = ep.Comments; //填加xls文件作者信息
            si.Title = ep.Title; //填加xls文件标题信息
            si.Subject = ep.Subject;//填加文件主题信息
            si.Keywords = ep.KeyWord;
            si.CreateDateTime = DateTime.Now;
            si.Comments = ep.Comments;
            Workbook.SummaryInformation = si;
            #endregion
        }
        /// <summary>
        /// 初始化显示的内容的单元格统一的样式
        /// </summary>
        /// <param name="fontweight">字体粗细</param>
        /// <param name="fontsize">字体大小</param>
        internal HSSFCellStyle SetContentFormat(short fontweight = , short fontsize = )
        {
            cellStyle = (HSSFCellStyle)Workbook.CreateCellStyle();
            //设置单元格border
            cellStyle.BorderRight = cellStyle.BorderLeft = cellStyle.BorderBottom = cellStyle.BorderTop = WholeBorderStyle;
            cellStyle.BottomBorderColor = cellStyle.RightBorderColor = cellStyle.LeftBorderColor = cellStyle.TopBorderColor = WholeBorderColor;
            cellStyle.Alignment = HorizontalAlignment.Center;
            cellStyle.VerticalAlignment = VerticalAlignment.Center;
            IFont font = Workbook.CreateFont();
            font.FontHeightInPoints = fontsize;
            font.Boldweight = fontweight;
            cellStyle.SetFont(font);
            return cellStyle;
        }
        #endregion
 
        #region 设置分组信息
        internal void SetGroupCell(List<GroupClass> ce)
        {
            GCell = ce;
        }
        #endregion
 
    }
 
    /// <summary>
    /// 拓展类
    /// </summary>
    public static class Extend
    {
 
        /// <summary>
        /// 泛型列表转成DataTable
        /// </summary>
        /// <typeparam name="T">泛型实体</typeparam>
        /// <param name="list">要转换的列表</param>
        /// <param name="titles">标题</param>
        /// <param name="fieldFuncs">字段委托</param>
        /// <returns></returns>
        internal static DataTable ToDataTable<T>(this List<T> list, string[] titles, params Func<T, string>[] fieldFuncs)
        {
            if (fieldFuncs.Length > )
            {
                if (titles == null || fieldFuncs.Length != titles.Length)
                {
                    throw new Exception("titles不能为空且必须与导出字段一一对应");
                }
 
                DataTable dt = new DataTable();
                //标题行
                DataRow headerDataRow = dt.NewRow();
                for (int i = ; i < fieldFuncs.Length; i++)
                {
                    dt.Columns.Add(new DataColumn());
                    headerDataRow[i] = titles[i];
                }
                dt.Rows.Add(headerDataRow);
 
                //内容行
                foreach (T item in list)
                {
                    DataRow dr = dt.NewRow();
                    for (int i = ; i < fieldFuncs.Length; i++)
                    {
                        dr[i] = fieldFuncs[i](item);
                    }
                    dt.Rows.Add(dr);
                }
                return dt;
            }
            else
            {
                Type listType = typeof(T);
                PropertyInfo[] properties = listType.GetProperties();
                if (properties.Length != titles.Length)
                {
                    throw new Exception("titles不能为空且必须与导出字段一一对应");
                }
 
                DataTable dt = new DataTable();
                //标题行
                DataRow headerDataRow = dt.NewRow();
                for (int i = ; i < properties.Length; i++)
                {
                    PropertyInfo property = properties[i];
                    dt.Columns.Add(new DataColumn());
                    headerDataRow[i] = titles[i];
                }
                dt.Rows.Add(headerDataRow);
 
                //内容行
                foreach (T item in list)
                {
                    DataRow dr = dt.NewRow();
                    for (int i = ; i < dt.Columns.Count; i++)
                    {
                        dr[i] = properties[i].GetValue(item, null);
                    }
                    dt.Rows.Add(dr);
                }
                return dt;
            }
        }
 
        /// <summary>
        /// List转DataTable
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        internal static DataTable ToDataTable<T>(this IEnumerable<T> list, string tableName)
        {
            //创建属性的集合
            List<PropertyInfo> pList = new List<PropertyInfo>();
            //获得反射的入口
            Type type = typeof(T);
            DataTable dt = new DataTable();
            dt.TableName = tableName;
            //把所有的public属性加入到集合 并添加DataTable的列
            System.Array.ForEach<PropertyInfo>(type.GetProperties(), p => { pList.Add(p); dt.Columns.Add(p.Name, p.PropertyType); });
            foreach (var item in list)
            {
                //创建一个DataRow实例
                DataRow row = dt.NewRow();
                //给row 赋值
                pList.ForEach(p => row[p.Name] = p.GetValue(item, null));
                //加入到DataTable
                dt.Rows.Add(row);
            }
            return dt;
        }
 
        /// <summary>
        /// 将WorkBook对象转换成内存流
        /// </summary>
        /// <param name="wv"></param>
        /// <returns></returns>
        public static MemoryStream SaveToStream(this HSSFWorkbook wv)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                wv.Write(ms);
                ms.Flush();
                ms.Position = ;
                return ms;
            }
        }
 
        internal static int[] ToIntArray(this string[] region)
        {
            ArrayList aList = new ArrayList();
            foreach (string i in region)
                aList.Add(Convert.ToInt32(i));
            return (int[])aList.ToArray(typeof(int));
        }
 
        internal static HorizontalAlignment ToHorAlign(this string str)
        {
            switch (str.ToLower())
            {
                case "center":
                    return HorizontalAlignment.Center;
                    break;
                case "left":
                    return HorizontalAlignment.Left;
                    break;
                case "right":
                    return HorizontalAlignment.Right;
                    break;
                default:
                    return HorizontalAlignment.Center;
                    break;
            }
            return HorizontalAlignment.Center;
        }
 
        internal static VerticalAlignment ToVerAlign(this string str)
        {
            switch (str.ToLower())
            {
                case "center":
                    return VerticalAlignment.Center;
                    break;
                case "top":
                    return VerticalAlignment.Top;
                    break;
                case "bottom":
                    return VerticalAlignment.Bottom;
                    break;
                default:
                    return VerticalAlignment.Center;
                    break;
            }
            return VerticalAlignment.Center;
        }
 
        /// <summary>
        ///  web导出excel
        /// </summary>
        /// <param name="hssf">已经被处理好的HSSFWorkbook对象</param>
        /// <param name="fileName">将要下载显示的名字</param>
        public static void ExportToWeb(this HSSFWorkbook hssf, string fileName)
        {
            byte[] buffers = hssf.SaveToStream().GetBuffer();
            ExportToWebExcel(buffers, fileName);
        }
 
        /// <summary>
        /// 本地存储到excel
        /// </summary>
        /// <param name="hssf">已经被处理好的HSSFWorkbook对象</param>
        /// <param name="fileName">文件名称，请自己包含路径，例如C:\\test.xls</param>
        public static void ExportToLocal(this HSSFWorkbook hssf, string fileName)
        {
            byte[] buffers = hssf.SaveToStream().GetBuffer();
            ExportToLocalExcel(buffers, fileName);
        }
 
        /// <summary>
        ///  本地存储到excel
        /// </summary>
        /// <param name="buffers">文件二进制流</param>
        /// <param name="fileName">文件目录例如C:\\test.xls</param>
        public static void ExportToLocalExcel(byte[] buffers, string fileName)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
            {
                fs.Write(buffers, , buffers.Length);
                fs.Flush();
            }
        }
 
        /// <summary>
        /// web导出excel
        /// </summary>
        /// <param name="buffers">文件二进制流</param>
        /// <param name="fileName">文件名称</param>
        public static void ExportToWebExcel(byte[] buffers, string fileName)
        {
            if (HttpContext.Current.Request.Browser.Type.IndexOf("IE") > -)
            {
                HttpContext.Current.Response.ContentType = "application/octet-stream";
                HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment; filename=" +
                    HttpUtility.UrlEncode(fileName, System.Text.Encoding.UTF8));
            }
            else
            {
                HttpContext.Current.Response.ContentType = "application/vnd.ms-excel";
                HttpContext.Current.Response.AddHeader("Content-Disposition", string.Format("attachment;filename*=utf-8'zh_cn'{0}", HttpUtility.UrlEncode(fileName)));
            }
            HttpContext.Current.Response.Charset = "gb2312";
            HttpContext.Current.Response.ContentEncoding = Encoding.GetEncoding("gb2312");
 
            HttpContext.Current.Response.Clear();
 
            HttpContext.Current.Response.BinaryWrite(buffers);
            System.Globalization.CultureInfo myCItrad = new System.Globalization.CultureInfo("zh-CN", true);
            HttpContext.Current.Response.End();
        }
 
    }
 
    #region Excel属性类
    /// <summary>
    /// 用于定义导出的excel属性
    /// </summary>
    public class ExcelProperty
    {
        public ExcelProperty() { }
        /// <summary>
        /// 文件基本属性
        /// </summary>
        /// <param name="company">公司名称 默认AaronYang</param>
        /// <param name="author">作者信息，默认 杨洋</param>
        /// <param name="ApplicationName">创建程序信息</param>
        /// <param name="LastAuthor">xls文件最后保存者信息</param>
        /// <param name="Comments">填加xls文件作者信息，备注</param>
        /// <param name="title">填加xls文件标题信息</param>
        /// <param name="Subject">填加文件主题信息</param>
        /// <param name="keyWord">关键词</param>
        /// <param name="catagory">类别</param>
        /// <param name="manager">经理</param>
        public ExcelProperty(string company, string author, string applicationName, string lastAuthor, string comments, string title, string subject, string keyWord, string catagory, string manager)
        {
            this.Company = company;
            this.Author = author;
            this.ApplicationName = applicationName;
            this.LastAuthor = lastAuthor;
            this.Comments = comments;
            this.Title = title;
            this.Subject = subject;
            this.Manager = manager;
            this.KeyWord = keyWord;
            this.Catagory = catagory;
        }
        /// <summary>
        /// 公司名称，默认 AaronYang
        /// </summary>
        private string company = "AaronYang";
        /// <summary>
        /// 公司名称，默认 AaronYang
        /// </summary>
        public string Company
        {
            get { return company; }
            set { company = value; }
        }
        /// <summary>
        /// 作者信息，默认 杨洋
        /// </summary>
        private string author = "杨洋";
        /// <summary>
        /// 作者信息，默认 杨洋
        /// </summary>
        public string Author
        {
            get { return author; }
            set { author = value; }
        }
        /// <summary>
        /// 创建程序信息
        /// </summary>
        private string applicationName = "";
        /// <summary>
        /// 创建程序信息
        /// </summary>
        public string ApplicationName
        {
            get { return applicationName; }
            set { applicationName = value; }
        }
        /// <summary>
        /// xls文件最后保存者信息
        /// </summary>
        private string lastAuthor = "";
        /// <summary>
        /// xls文件最后保存者信息
        /// </summary>
        public string LastAuthor
        {
            get { return lastAuthor; }
            set { lastAuthor = value; }
        }
        /// <summary>
        ///填加xls文件作者信息，备注
        /// </summary>
        private string comments = "";
        /// <summary>
        ///填加xls文件作者信息，备注
        /// </summary>
        public string Comments
        {
            get { return comments; }
            set { comments = value; }
        }
        /// <summary>
        /// 填加xls文件标题信息
        /// </summary>
        private string title = "";
        /// <summary>
        /// 填加xls文件标题信息
        /// </summary>
        public string Title
        {
            get { return title; }
            set { title = value; }
        }
        /// <summary>
        /// 填加文件主题信息
        /// </summary>
        private string subject = "";
        /// <summary>
        /// 填加文件主题信息
        /// </summary>
        public string Subject
        {
            get { return subject; }
            set { subject = value; }
        }
        /// <summary>
        /// 关键字
        /// </summary>
        private string keyWord = "";
        /// <summary>
        /// 关键字
        /// </summary>
        public string KeyWord
        {
            get { return keyWord; }
            set { keyWord = value; }
        }
        /// <summary>
        /// 类别
        /// </summary>
        private string catagory = "";
        /// <summary>
        /// 类别
        /// </summary>
        public string Catagory
        {
            get { return catagory; }
            set { catagory = value; }
        }
        /// <summary>
        /// 经理
        /// </summary>
        private string manager = "";
        /// <summary>
        /// 经理
        /// </summary>
        public string Manager
        {
            get { return manager; }
            set { manager = value; }
        }
 
    }
    #endregion
 
    #region 定义Json表头的格式
    /// <summary>
    /// 关于表头单元格设置属性：字体默认：黑体，字体大小默认12
    /// </summary>
    internal class AttributeList
    {
        /// <summary>
        /// 显示的文字
        /// </summary>
        public string title { get; set; }
        /// <summary>
        /// 显示方式
        /// </summary>
        public string align { get; set; }
        /// <summary>
        /// 垂直显示方式
        /// </summary>
        public string valign { get; set; }
        /// <summary>
        /// 背景颜色.例如#000000
        /// </summary>
        public string bgcolor { get; set; }
        /// <summary>
        /// 字体大小
        /// </summary>
        public short? fontsize { get; set; }
        /// <summary>
        /// 字体颜色,例如#000000
        /// </summary>
        public string fontcolor { get; set; }
        /// <summary>
        /// 单元格合并位置，（fromRow,toRow,fromColumn,toColumn）
        /// </summary>
        public string cellregion { get; set; }
        /// <summary>
        /// 字体名称
        /// </summary>
        public string fontName { get; set; }
        /// <summary>
        /// 表头文字是否加粗，默认加粗
        /// </summary>
        public string fontweight { get; set; }
        /// <summary>
        /// 宽度
        /// </summary>
        public int? width { get; set; }
        /// <summary>
        /// 高度
        /// </summary>
        public int? height { get; set; }
 
        /// <summary>
        ///是否是斜体
        /// </summary>
        public bool? IsItalic { get; set; }
        /// <summary>
        /// 是否有中间线
        /// </summary>
        public bool? IsStrikeout { get; set; }
        /// <summary>
        /// 设置下划线
        /// </summary>
        public bool? Underline { get; set; }
 
    }
 
    /// <summary>
    /// 合并组，暂时支持一列
    /// </summary>
    public class GroupClass
    {
        /// <summary>
        /// 从哪一行开始
        /// </summary>
        public int? index { get; set; }
        /// <summary>
        /// 分组后每组中多少个值
        /// </summary>
        public int?  groupCount{ get; set; }
        /// <summary>
        /// 要合并的那一列的索引
        ///  </summary>
        public int column { get; set; }
 
    }
    /// <summary>
    /// 报表表格头部信息
    /// </summary>
    internal class HeadInfo
    {
        public IList<AttributeList> head { get; set; }
        public int? rowspan { get; set; }
        public string sheetname { get; set; }
        /// <summary>
        /// 默认单元格宽度
        /// </summary>
        public int? defaultwidth { get; set; }
        /// <summary>
        /// 默认行高度
        /// </summary>
        public int? defaultheight { get; set; }
        /// <summary>
        /// 默认黑色,表格边框颜色
        /// </summary>
        public string bordercolor { get; set; }
        /// <summary>
        /// 边框风格，默认 thin
        /// </summary>
        public string borderstyle { get; set; }
    }
    /// <summary>
    /// 根节点
    /// </summary>
    internal class Root
    {
        public HeadInfo root { get; set; }
    }
 
    #endregion
 
    /// <summary>
    /// excel 构建
    /// 仿照AutoMaper 调用方式
    /// 调用方式
    /// new ExportBuilder<CustomerInsureModel>()
    ///         .Column(c => c.InsureNum)
    ///         .Column(c => c.Applicant)
    ///         .Column(c => c.Insurant)
    ///         .Column(c => c.CompanyName)
    ///         .Column(c => c.ProdName)
    ///         .Column(c => c.InsureTime, c => c.InsureTime.Value.ToString("yyyy-MM-dd HH:mm"))
    ///         .Column(c => c.IsMergePay, c => c.IsMergePay ? c.OrderNum : string.Empty)
    ///         .Column(c => c.BuySinglePrice, c => c.BuySinglePrice.Value.ToString("0.00"))
    ///         .Column(c => c.OnlinePaymnet, c => c.OnlinePaymnet.GetDescription())
    ///         .Export(vdata.ToList(), "用户投保信息.xls");
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ExportBuilder<T>
    {
        List<string> titles = new List<string>();
        //循环进行添加func字段的值
        List<Func<T, string>> funcs = new List<Func<T, string>>();
        private ExcelHelper excel;
        internal ExcelHelper Excel
        {
            get
            {
                if (excel == null)
                {
                    excel = new ExcelHelper();
                }
                return excel;
            }
            set { excel = value; }
        }
 
        /// <summary>
        /// 定义列
        /// 2012-08-15 支持 .Column(m => m.Platform01.ToString()) 写法
        /// </summary>
        /// <param name="member">解析Display特性得到列名，如不存在，则使用列名</param>
        /// <returns></returns>
        public ExportBuilder<T> Column(Expression<Func<T, string>> member)
        {
            //var memberParam = member.Body as MemberExpression;
            titles.Add(ExcelUtility.GetDisplayName(member.Body));
            var convert = member.Compile();
            funcs.Add(convert);
            return this;
        }
        public void SetTitleAndColumn(Expression<Func<T, string>> member)
        {
            titles.Add(ExcelUtility.GetDisplayName(member.Body));
            var convert = member.Compile();
            funcs.Add(convert);
        }
        /// <summary>
        /// 定义列
        /// </summary>
        /// <param name="member"></param>
        /// <param name="title">列名</param>
        /// <returns></returns>
        public ExportBuilder<T> Column(Expression<Func<T, string>> member, string title)
        {
            var memberParam = member.Body as MemberExpression;
            titles.Add(title);
            var convert = member.Compile();
            funcs.Add(convert);
            return this;
        }
 
        /// <summary>
        /// 定义列
        /// </summary>
        /// <param name="member">解析Display特性得到列名，如不存在，则使用列名</param>
        /// <param name="convert">定义数据输出格式</param>
        /// <returns></returns>
        public ExportBuilder<T> Column(Expression<Func<T, object>> member, Func<T, string> convert)
        {
            //var memberParam = member.Body as MemberExpression;
            titles.Add(ExcelUtility.GetDisplayName(member.Body));
            funcs.Add(convert);
            return this;
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="member"></param>
        /// <param name="title">列名</param>
        /// <param name="convert">定义数据输出格式</param>
        /// <returns></returns>
        public ExportBuilder<T> Column(Expression<Func<T, object>> member, string title, Func<T, string> convert)
        {
            var memberParam = member.Body as MemberExpression;
            titles.Add(title);
            funcs.Add(convert);
            return this;
        }
 
        /// <summary>
        /// 编辑已经添加的转换
        /// </summary>
        /// <param name="name"></param>
        /// <param name="convert"></param>
        /// <returns></returns>
        public ExportBuilder<T> Edit(string name, Func<T, string> convert)
        {
            var index = titles.FindIndex(m => m == name);
            if (index > -)
            {
                funcs[index] = convert;
            }
            return this;
        }
 
        /// <summary>
        /// 设置Excel属性
        /// </summary>
        /// <param name="ext"></param>
        /// <returns></returns>
        public ExportBuilder<T> SetExcelProperty(ExcelProperty ext)
        {
            Excel.SetWorkbook(ext);
            return this;
        }
 
        /// <summary>
        /// 导出WEB
        /// </summary>
        /// <param name="list">数据源</param>
        /// <param name="fileName">文件名</param>
        /// <param name="headJosn">表头JSON</param>
        public void Export(List<T> list, string fileName, string headJson)
        {
            Excel.ExportToWeb<T>(list, fileName, titles.ToArray(), headJson, funcs.ToArray());
        }
       /// <summary>
        /// 导出WEB，含分组
       /// </summary>
       /// <param name="list">数据源（分组后的）</param>
       /// <param name="fileName">文件名</param>
       /// <param name="headJosn">表头JSON</param>
        /// <param name="group">分组集合</param>
        /// <param name="groupColumn">分组所在的列，索引从0开始</param>
        public void Export(List<T> list, string fileName, string headJson, List<GroupClass> group, int groupColumn)
        {
            Excel.ExportToWeb<T>(list, fileName, titles.ToArray(), headJson, group, groupColumn, funcs.ToArray());
        }
        /// <summary>
        /// 导出到本地存储
        /// </summary>
        /// <param name="list">数据源</param>
        /// <param name="fileName">文件名</param>
        /// <param name="headJson">表头JSON</param>
        public void ExportToLocal(List<T> list, string fileName, string headJson)
        {
            Excel.ExportToLocal<T>(list, fileName, titles.ToArray(), headJson, funcs.ToArray());
        }
        /// <summary>
        /// 导出到本地存储，含分组
        /// </summary>
        /// <param name="list">数据源（分组后的）</param>
        /// <param name="fileName">文件名</param>
        /// <param name="headJson">表头JSON</param>
        /// <param name="group">分组集合</param>
        /// <param name="groupColumn">分组所在的列，索引从0开始</param>
        public void ExportToLocal(List<T> list, string fileName, string headJson, List<GroupClass> group, int groupColumn)
        {
            Excel.ExportToLocal<T>(list, fileName, titles.ToArray(), headJson, group, groupColumn, funcs.ToArray());
        }
    }
 
}

using MyNPOI.Excel;
using NPOI.SS.UserModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace GTJ.Utility.MyNPOI.Excel
{
   public class ExcelUtility
    {
        private static IWorkbook workbook = null;

        public static void CreateWorkbook(Stream file)
        {
            workbook = WorkbookFactory.Create(file);
        }

        /// <summary>
        /// 解析Excel
        /// </summary>
        /// <param name="strFileName">Excel文件路径</param>
        /// <param name="SheetIndex">sheet号</param>
        /// <param name="dataIndex">数据开始行</param>
        /// <param name="needHeader"></param>
        /// <returns></returns>
        public static List<StringBuilder> ImportExceltoList(int SheetIndex, int dataIndex)
        {
            int num = ;
            try
            {
                List<StringBuilder> listTemp = new List<StringBuilder>();

                ISheet sheet = workbook.GetSheetAt(SheetIndex);
                int rows = sheet.LastRowNum;//获得总行数

                for (int i = dataIndex; i <= rows; i++)
                {
                    num = i;
                    IRow row = sheet.GetRow(i);
                    if (row == null)
                    {
                        break;
                    }
                    int cellnum = row.LastCellNum;//单元格数
                    StringBuilder sb = new StringBuilder();
                    for (int j = ; j < cellnum; j++)
                    {
                        ICell cell = row.GetCell(j);
                        if (cell != null)
                        {
                            cell.SetCellType(CellType.String);//全都设置成String
                            string value = cell.StringCellValue;
                            sb.Append(value.Trim()).Append(";");

                        }
                        else
                        {
                            sb.Append(";");
                        }
                    }
                    listTemp.Add(sb);//每行数据以分号（;）隔开拼接成字符串存入list中
                }
                return listTemp;
            }
            catch
            {
                GTJ.Utility.ScriptHelper.writer(System.Web.HttpContext.Current.Response, "导入Excel出错，在" + num + "行有错误，请检查");
            }
            return null;
        }

        /// <summary>
        /// 进行数据库的导出
        /// </summary>
        /// <typeparam name="T">model 属性值</typeparam>
        /// <param name="list"></param>
        /// <param name="fileName"></param>
        /// <param name="headJson"></param>
        /// <param name="funcs"></param>
        public static void ExportToLocal<T>(List<T> list, string fileName, string headJson,  params Expression<Func<T,string>>[] funcs)
        {
            ExportBuilder<T>  ExportBuild = new ExportBuilder<T>();
            for(var i=;i< funcs.Length; i++)
            {
                //设置对应的title和列的情况
                ExportBuild.SetTitleAndColumn(funcs[i]);

            }
            ExportBuild.ExportToLocal(list,fileName,headJson);
        }
        /// <summary>
        ///  导入到web端
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <param name="fileName"></param>
        /// <param name="headJson"></param>
        /// <param name="funcs"></param>
        public static void ExportToWeb<T>(List<T> list, string fileName, string headJson, params Expression<Func<T, string>>[] funcs)
        {
            ExportBuilder<T> ExportBuild = new ExportBuilder<T>();
            for (var i = ; i < funcs.Length; i++)
            {
                //设置对应的title和列的情况
                ExportBuild.SetTitleAndColumn(funcs[i]);

            }
            ExportBuild.Export(list, fileName, headJson);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json;
using System.IO;
using System.Linq.Expressions;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using System.ComponentModel;

namespace GTJ.Utility.MyNPOI
{
    /// <summary>
    ///JsonUtility 的摘要说明
    /// </summary>
    public class Utility
    {
        /// <summary>
        /// Json工具类
        /// </summary>
        public static class JsonUtility
        {
            /// <summary>
            /// 添加时间转换器
            /// </summary>
            /// <param name="serializer"></param>
            private static void AddIsoDateTimeConverter(JsonSerializer serializer)
            {
                IsoDateTimeConverter idtc = new IsoDateTimeConverter();
                //定义时间转化格式
                idtc.DateTimeFormat = "yyyy-MM-dd";
                //idtc.DateTimeFormat = "yyyy-MM-dd";
                serializer.Converters.Add(idtc);
            }

            /// <summary>
            /// Json转换配置
            /// </summary>
            /// <param name="serializer"></param>
            private static void SerializerSetting(JsonSerializer serializer)
            {
                serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                //serializer.NullValueHandling = NullValueHandling.Ignore;
                //serializer.MissingMemberHandling = MissingMemberHandling.Ignore;
                //serializer.DefaultValueHandling = DefaultValueHandling.Ignore;
            }

            /// <summary>
            /// 返回结果消息编码
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="sucess"></param>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="data"></param>
            /// <returns></returns>
            public static string ReturnMessage(bool sucess, int total, string message, string exMessage, string data)
            {
                message = message.Replace("'", "").Replace("\"", "").Replace("<", "").Replace(">", "");
                exMessage = exMessage.Replace("'", "").Replace("\"", "").Replace("<", "").Replace(">", "");

                return string.Format("{{success:{0},total:{1},data:{2},message:\"{3}\",exMessage:\"{4}\"}}",
                    sucess.ToString().ToLower(), total, data, message, exMessage);
            }

            /// <summary>
            /// 返回失败信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <returns></returns>
            public static string ReturnFailureMessage(string message, string exMessage)
            {
                return ReturnMessage(false, , message, exMessage, "[]");
            }

            /// <summary>
            /// 返回失败信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <returns></returns>
            public static string ReturnFailureMessageTouch(string message, string exMessage)
            {
                return "{\"success\":\"false\",\"msg\":\"" + exMessage + "\"}";
            }

            /// <summary>
            /// 返回成功信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="total"></param>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="objList"></param>
            /// <returns></returns>
            public static string ReturnSuccessMessage<T>(int total, string message, string exMessage, List<T> objList)
            {
                string data = ListToJson<T>(objList);
                return ReturnMessage(true, total, message, exMessage, data);
            }

            public static string ReturnSuccessMessageTouch<T>(T obj)
            {
                string data = ObjectToJson<T>(obj);
                return data;
            }

            /// <summary>
            /// 返回成功信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="total"></param>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="objList"></param>
            /// <returns></returns>
            public static string ReturnSuccessMessage(string message, string exMessage)
            {
                return ReturnMessage(true, , message, exMessage, "[]");
            }

            /// <summary>
            /// 返回成功信息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="total"></param>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="objList"></param>
            /// <returns></returns>
            public static string ReturnSuccessMessageTouch(string message, string exMessage)
            {
                return "{\"success\":\"true\",\"msg\":\"" + message + "\"}";
            }

            /// <summary>
            /// 返回成功信息
            /// </summary>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="data">JSON 对象</param>
            /// <returns></returns>
            public static string ReturnSuccessMessage(string message, string exMessage, string data)
            {
                return ReturnMessage(true, , message, exMessage, "[" + data + "]");
            }

            /// <summary>
            /// 返回成功消息
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="total"></param>
            /// <param name="message"></param>
            /// <param name="exMessage"></param>
            /// <param name="obj"></param>
            /// <returns></returns>
            public static string ReturnSuccessMessage<T>(int total, string message, string exMessage, T obj)
            {
                string data = ObjectToJson<T>(obj);
                return ReturnMessage(true, total, message, exMessage, data);
            }

            /// <summary>
            /// 把对象列表编码为Json数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="objList"></param>
            /// <returns></returns>
            public static string ListToJson<T>(List<T> objList)
            {
                JsonSerializer serializer = new JsonSerializer();
                SerializerSetting(serializer);
                AddIsoDateTimeConverter(serializer);

                using (TextWriter sw = new StringWriter())
                using (JsonWriter writer = new JsonTextWriter(sw))
                {
                    serializer.Serialize(writer, objList);
                    return sw.ToString();
                }
            }

            /// <summary>
            ///  把一个对象编码为Json数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="obj"></param>
            /// <returns></returns>
            public static string ObjectToJson<T>(T obj)
            {
                JsonSerializer serializer = new JsonSerializer();
                SerializerSetting(serializer);
                AddIsoDateTimeConverter(serializer);

                using (TextWriter sw = new StringWriter())
                using (JsonWriter writer = new JsonTextWriter(sw))
                {
                    serializer.Serialize(writer, obj);
                    return sw.ToString();
                }
            }

            /// <summary>
            /// 根据传入的Json数据，解码为对象(一个)
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="data"></param>
            /// <returns></returns>
            public static T DecodeObject<T>(string data)
            {
                JsonSerializer serializer = new JsonSerializer();
                serializer.MissingMemberHandling = MissingMemberHandling.Ignore;
                AddIsoDateTimeConverter(serializer);
                StringReader sr = new StringReader(data);
                return (T)serializer.Deserialize(sr, typeof(T));

            }

            /// <summary>
            /// 功能同DecodeObject
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="data"></param>
            /// <returns></returns>
            public static List<T> DecodeObjectList<T>(string data)
            {
                JsonSerializer serializer = new JsonSerializer();
                serializer.MissingMemberHandling = MissingMemberHandling.Ignore;
                AddIsoDateTimeConverter(serializer);
                StringReader sr = new StringReader(data);
                return (List<T>)serializer.Deserialize(sr, typeof(List<T>));
            }

            public static string EncodeAjaxResponseJson(string jsonString, string callback)
            {
                String responseString = "";
                //判断是否jsonp调用
                if (!String.IsNullOrEmpty(callback))
                {
                    //jsonp调用，需要封装回调函数，并返回
                    responseString = callback + "(" + jsonString + ")";
                }
                else
                {
                    //普通ajax调用，直接返回Json数据
                    responseString = jsonString;
                }

                return responseString;
            }

            public static string ExtGridSortInfo(string property, string direction)
            {
                return string.Format("[{{\"property\":\"{0}\",\"direction\":\"{1}\"}}]", property, direction);
            }

        }

    }

    public static class ExcelUtility
    {
        /// <summary>
        /// [Display(Name = "")]
        /// 获得类属性中标记的名称
        /// </summary>
        /// <param name="expr"></param>
        /// <returns></returns>
        public static string GetDisplayName(Expression expr)
        {
            var memberParam = expr as MemberExpression;
            if (memberParam != null)
            {
                return GetDisplayName(memberParam);
            }
            var unary = expr as UnaryExpression;
            if (unary != null)
            {
                return GetDisplayName(unary.Operand as MemberExpression);
            }
            var call = expr as MethodCallExpression;
            if (call != null)
            {
                return GetDisplayName(call.Object as MemberExpression);
            }

            return string.Empty;

        }

        /// <summary>
        /// [Display(Name = "记住帐号")]
        /// 获得类属性中标记的中文名
        /// </summary>
        /// <param name="memberParam"></param>
        /// <returns></returns>
        private static string GetDisplayName(MemberExpression memberParam)
        {
            var name = memberParam.Member.Name;
            var property = memberParam.Member.ReflectedType.GetProperty(name);
            var displays = property.GetCustomAttributes(typeof(DisplayAttribute), false);
            if (displays == null || displays.Length == )
                return property.Name;
            else
                return (displays[] as DisplayAttribute).Name;
        }
    }

    public static class typeUtility
    {
        /// <summary>
        /// 获取枚举的描述
        /// </summary>
        /// <param name="enumType">枚举类型</param>
        /// <param name="fieldName">枚举字段名称</param>
        /// <returns></returns>
        public static string GetDescription(Type enumType, string fieldName)
        {
            if (!enumType.IsEnum)
                throw new InvalidOperationException("亲，必须是Enum类型哦，请检查类型是否正确哈。");

            FieldInfo field = enumType.GetField(fieldName);
            DescriptionAttribute[] attributes = (DescriptionAttribute[])field.GetCustomAttributes(
            typeof(DescriptionAttribute), false);
            return (attributes.Length > ) ? attributes[].Description : fieldName;
        }

        /// <summary>
        /// 获取枚举的描述
        /// </summary>
        /// <typeparam name="TEnum">枚举类型</typeparam>
        /// <param name="enumObject">枚举对象</param>
        /// <returns></returns>
        public static string GetDescription<TEnum>(this TEnum enumObject)
        {
            FieldInfo field = enumObject.GetType().GetField(enumObject.ToString());
            if (field == null)
            {
                return "";
            }
            DescriptionAttribute[] attributes = (DescriptionAttribute[])field.GetCustomAttributes(
                typeof(DescriptionAttribute), false);
            return (attributes.Length > ) ? attributes[].Description : enumObject.ToString();
        }
    }
}