ASP.NET MVC Excel 导入导出 ASP.NET Web API Excel 下载 C# Excel NPOI 导入导出

原创 已于 2024-06-06 11:17:17 修改 · 5k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c#excel导入导出 #mvc excel导入导出 #excel导入导出
于 2016-09-29 08:53:20 首次发布
本文介绍了使用ASP.NET MVC和Web API实现Excel文件的导入导出方法。包括解决OLEDB驱动未注册的问题、上传并解析Excel文件、将数据插入数据库、导出数据为CSV或Excel文件等步骤。

注意：服务器需要安装office软件

1、Excel导入
   提示：未在本地计算机上注册“Microsoft.Jet.OLEDB.4.0”提供程序。
              未在本地计算机上注册“Microsoft.ACE.OLEDB.12.0”提供程序。
   解决方法如下：
   打开IIS管理器 -> 应用程序管理池 -> 选择相应程序的应用池 -> 
   右键 -> 应用程序池默认设置 -> 常规选项卡 -> 
   启用32位应用程序设置成 True

上传excel文件代码

public ActionResult EditAction(FormCollection collection)
{
    try
    {
        string filePath = string.Empty;
        string fileType = string.Empty;
        HttpPostedFileBase postedFile = Request.Files["fileImage"];

        #region 上传文件

        fileType = Path.GetExtension(postedFile.FileName).ToLower();//文件的后缀名(小写)

        FileUploadResult result = FileHelper.CreatePostedFileToImage(postedFile, @"upload\excel\");
        if (result != null && result.Code == (int)CodeEnum.Success)
        {
            filePath = result.Path;
        }
        filePath = ConstantParamInfo.PhysicalApplicationPath + filePath;

        ImportSql(filePath, fileType);
        #endregion
    }
    catch (Exception ex)
    {
    }
    return RedirectToAction("Index", "CityManage");
}

读取excel文件数据，插入数据库数据代码

        public bool ImportSql(string excelPath, string fileType)
        {
            string strCon = string.Empty;

            if (fileType == ".xls")
                strCon = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + excelPath + ";Extended Properties='Excel 8.0;HDR=YES;IMEX=1'";
            else
                strCon = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + excelPath + ";Extended Properties='Excel 12.0;HDR=YES;IMEX=1'";

            System.Data.OleDb.OleDbConnection Conn = new System.Data.OleDb.OleDbConnection(strCon);
            string strCom = "SELECT * FROM [Sheet1$]";
            string strComNew = "SELECT * FROM [Sheet2$]";
            DataTable dt;
            DataTable dtNew;
            try
            {
                #region city table

                System.Data.OleDb.OleDbDataAdapter myCommand = new System.Data.OleDb.OleDbDataAdapter(strCom, strCon);
                DataSet ds = new DataSet();
                myCommand.Fill(ds, "[Sheet1$]");
                dt = ds.Tables[0];
                if (dt != null)
                {
                    if (cityBiz.DeleteAll())
                    {
                        for (int i = 0; i < dt.Rows.Count; i++)
                        {
                            var model = new City
                            {
                                ID = Convert.ToInt32(dt.Rows[i][0].ToString()),
                                ProvincialID = 0,
                                Title = dt.Rows[i][1].ToString(),
                                State = "A"
                            };
                            cityBiz.Add(model);
                        }
                    }
                }
                #endregion

                #region Hospital table

                System.Data.OleDb.OleDbDataAdapter myCommandNew = new System.Data.OleDb.OleDbDataAdapter(strComNew, strCon);
                DataSet dsNew = new DataSet();
                myCommandNew.Fill(dsNew, "[Sheet2$]");
                dtNew = dsNew.Tables[0];
                if (dtNew != null)
                {
                    if (hospitalBiz.DeleteAll())
                    {
                        for (int i = 0; i < dtNew.Rows.Count; i++)
                        {
                            var model = new Hospital
                            {
                                CityId = Convert.ToInt32(dtNew.Rows[i][0].ToString()),
                                Title = dtNew.Rows[i][1].ToString(),
                                CreateBy = 0
                            };
                            hospitalBiz.Add(model);
                        }
                    }
                }

                #endregion

                return true;
            }
            catch (Exception ex)
            {
                logger.Error("ImportSql()" + ex.Message);
            }
            return false;
        }

2、ASP.NET MVC Excel 下载 数据导出

        public ActionResult ExportCSV()
        {
            try
            {
                string Transactions = Request.Form["item"];
                List<long> arr = new List<long>();
                string[] strtemp = Transactions.Split(',');
                foreach (string strs in strtemp)
                {
                    arr.Add(long.Parse(strs));
                }
                //List<PaymentMaster> PaymentList = PaymentBusi.GetTransactionDetails(this.CurrentAccount.SiteID, arr.ToArray());
                List<PaymentMaster> PaymentList = new List<PaymentMaster>();

                MemoryStream stream = new MemoryStream();
                StreamWriter writer = new StreamWriter(stream);

                writer.WriteLine("AccountName,Date,TransactionID,ItemDesc,Amount,TransactionTotal");
                writer.Flush();
                for (int i = 0; i < PaymentList.Count; i++)
                {
                    string Summary = string.Empty;
                    string PaymentIDF = string.Empty;
                    string PaymentID = string.Empty;
                    if (PaymentList[i].PaymentItems.Count > 0)
                        Summary = DelQuota(PaymentList[i].PaymentItems[0].Summary);

                    if (PaymentList[i].PaymentID > 0)
                        PaymentIDF = PaymentList[i].PaymentID.ToString();

                    writer.WriteLine(string.Format("{0},{1},{2},{3},{4},{5}",
                       DelQuota(PaymentList[i].AccountName),
                       Convert.ToDateTime(PaymentList[i].CreateDate, GetMDDYYFormat()).ToShortDateString(),
                       PaymentList[i].PaymentID,
                       Summary,
                       "$" + PaymentList[i].PaymentItems[0].Amount.ToString(),
                       ""
                      ));

                    if (PaymentList[i].PaymentItems.Count > 0)
                    {
                        for (int j = 0; j < PaymentList[i].PaymentItems.Count; j++)
                        {

                            if (PaymentList[i].PaymentItems[j].PaymentID > 0)
                                PaymentID = PaymentList[i].PaymentItems[j].PaymentID.ToString();
                            if (j != 0)
                            {
                                writer.WriteLine(string.Format("{0},{1},{2},{3},{4},{5}",
                                                              "",
                                                              "",
                                                              PaymentID,
                                                              DelQuota(PaymentList[i].PaymentItems[j].Summary),
                                                              "$" + PaymentList[i].PaymentItems[j].Amount.ToString(),
                                                              ""
                                                          ));
                            }
                        }
                        writer.WriteLine(string.Format("{0},{1},{2},{3},{4},{5}",
                               "",
                               "",
                               "",
                               "",
                               "",
                               "$" + PaymentList[i].Amount.ToString()
                        ));
                    }
                    writer.Flush();
                }

                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Close();

                return File(buffer, "text/plain", "PaymentInvoice.csv");
            }
            catch (Exception)
            {
                return View();
            }
        }

        public string DelQuota(string str)
        {
            string result = str;
            string[] strQuota = { "~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "`", ";", "'", ",", ".", "/", ":", "/,", "<", ">", "?" };
            for (int i = 0; i < strQuota.Length; i++)
            {
                if (result.IndexOf(strQuota[i]) > -1)
                    result = result.Replace(strQuota[i], "");
            }
            return result;
        }

        public System.Globalization.DateTimeFormatInfo GetMDDYYFormat()
        {
            System.Globalization.DateTimeFormatInfo dtFormat = new System.Globalization.DateTimeFormatInfo();
            dtFormat.ShortDatePattern = "M/dd/yy";
            return dtFormat;
        }

    public class PaymentMaster
    {
        public string PaymentMethod { get; set; }
        public long PaymentID { get; set; }
        public long AccountID { get; set; }
        public long ContactID { get; set; }
        public int Status { get; set; }
        public long SiteID { get; set; }
        public long ClientID { get; set; }
        public string LoginName { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Amount { get; set; }
        public int DetailCount { get; set; }
        public string Description { get; set; }
        public System.DateTime ModifyDate { get; set; }
        public string CreateDate { get; set; }

        public List<long> RentalIDs { get; set; }

        public List<PaymentDetail> PaymentItems { get; set; }
        public List<string> UnitNumbers { get; set; }

        public string AccountName { get; set; }

    }

    public class PaymentDetail
    {
        public long DetailID { get; set; }
        public int DetailType { get; set; }
        public long PaymentID { get; set; }
        public long AccountID { get; set; }
        public long ContactID { get; set; }
        public long RentalID { get; set; }

        public int Status { get; set; }

        public long SiteID { get; set; }
        public string Summary { get; set; }
        public string UnitNumber { get; set; }
        public string UnitSize { get; set; }
        public int UnitCount { get; set; }
        public string PaidThruDate { get; set; }

        //Public Property Dimensions As String

        public string Amount { get; set; }
        public string TransactionNumber { get; set; }
        public string Description { get; set; }

        public System.DateTime ModifyDate { get; set; }
        public System.DateTime CreateDate { get; set; }

    }

3、ASP.NET Web API Excel 下载 数据导出

[Route("api/area/export")]
[HttpGet]
public HttpResponseMessage Export()
{
    List<sys_area> list = new List<sys_area>();
    list.Add(new sys_area { code_id = "110000", name = "北京市" });
    list.Add(new sys_area { code_id = "130000", name = "河北省" });

    #region excel
    var runNum = 0;
    var workbook = new XSSFWorkbook();
    var worksheet = workbook.CreateSheet("Sheet1");
    var workRowHead = worksheet.CreateRow(runNum);

    workRowHead.CreateCell(0).SetCellValue("编号");
    workRowHead.CreateCell(1).SetCellValue("省");

    runNum++;

    foreach (var item in list)
    {
        var workRow = worksheet.CreateRow(runNum);
        workRow.CreateCell(0).SetCellValue(item.code_id);
        workRow.CreateCell(1).SetCellValue(item.name);
        runNum++;
    }

    using (MemoryStream memoryStream = new MemoryStream())
    {
        workbook.Write(memoryStream);

        var result = new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new ByteArrayContent(memoryStream.ToArray())
        };
        result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
        {
            FileName = $"地区{DateTime.Now.ToString("yyyyMMddhhmmss")}.xlsx"
        };
        return result;
    }
    #endregion
}

Html 前端调用

$("#btnExport").click(function () {
    window.location.href = "http://" + window.location.host +"/Area/Export?code=&name=";
});

*、NPOIHelper.cs

using NPOI.HPSF;
using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using System.Data;
using System.IO;
using System.Text;

namespace Yuebon.Commons.Helpers
{
    /// <summary>
    /// office 导入导出
    /// </summary>
    public class NPOIHelper
    {
        /// <summary>
        /// DataTable 导出到 Excel 的 MemoryStream
        /// </summary>
        /// <param name="dtSource">源 DataTable</param>
        /// <param name="strHeaderText">表头文本 空值未不要表头标题</param>
        /// <returns></returns>
        public static MemoryStream ExportExcel(DataTable dtSource, string strHeaderText)
        {
            HSSFWorkbook workbook = new HSSFWorkbook();
            ISheet sheet = workbook.CreateSheet();
            #region 文件属性
            DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
            dsi.Company = "yuebon.com";
            workbook.DocumentSummaryInformation = dsi;
            SummaryInformation si = PropertySetFactory.CreateSummaryInformation();
            si.Author = "yuebon.com";
            si.ApplicationName = "yuebon.com";
            si.LastAuthor = "yuebon.com";
            si.Comments = "";
            si.Title = "";
            si.Subject = "";
            si.CreateDateTime = DateTime.Now;
            workbook.SummaryInformation = si;
            #endregion
            ICellStyle dateStyle = workbook.CreateCellStyle();
            IDataFormat format = workbook.CreateDataFormat();
            dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");
            int[] arrColWidth=new int[dtSource.Columns.Count];
            foreach(DataColumn item in dtSource.Columns)
            {
                arrColWidth[item.Ordinal] = Encoding.GetEncoding("gb2312").GetBytes(item.ColumnName.ToString()).Length;
            }
            for (int i = 0; i < dtSource.Rows.Count;i++ )
            {
                for (int j = 0; j < dtSource.Columns.Count;j++ )
                {
                    int intTemp = Encoding.GetEncoding("gb2312").GetBytes(dtSource.Rows[i][j].ToString()).Length;
                    if (intTemp > arrColWidth[j])
                    {
                        arrColWidth[j] = intTemp;
                    }
                }
            }
            int rowIndex = 0;
            int intTop = 0;
            foreach(DataRow row in dtSource.Rows)
            {
                #region 新建表、填充表头、填充列头，样式
                if (rowIndex == 65535 || rowIndex == 0)
                {
                    if (rowIndex != 0)
                    {
                        sheet = workbook.CreateSheet();
                    }
                    intTop = 0;
                    #region 表头及样式
                    {
                        if (strHeaderText.Length > 0)
                        {
                            IRow headerRow = sheet.CreateRow(intTop);
                            intTop += 1;
                            headerRow.HeightInPoints = 25;
                            headerRow.CreateCell(0).SetCellValue(strHeaderText);
                            ICellStyle headStyle = workbook.CreateCellStyle();
                            headStyle.Alignment = HorizontalAlignment.Center;
                            IFont font = workbook.CreateFont();
                            font.FontHeightInPoints = 20;
                            font.Boldweight = 700;
                            headStyle.SetFont(font);
                            headerRow.GetCell(0).CellStyle = headStyle;
                            sheet.AddMergedRegion(new NPOI.SS.Util.CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));
                           
                        }
                    }
                    #endregion
                    #region  列头及样式
                    {
                        IRow headerRow = sheet.CreateRow(intTop);
                        intTop += 1;
                        ICellStyle headStyle = workbook.CreateCellStyle();
                        headStyle.Alignment = HorizontalAlignment.Center;
                        IFont font = workbook.CreateFont();
                        font.Boldweight = 700;
                        headStyle.SetFont(font);
                        foreach(DataColumn column in dtSource.Columns)
                        {
                            headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
                            headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
                            //设置列宽
                            sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256);
                        }
                       
                        
                    }
                    #endregion
                    rowIndex = intTop;
                }
                #endregion
                #region 填充内容
                IRow dataRow = sheet.CreateRow(rowIndex);
                foreach(DataColumn column in dtSource.Columns)
                {
                    ICell newCell = dataRow.CreateCell(column.Ordinal);
                    string drValue = row[column].ToString();
                    switch (column.DataType.ToString())
                    { 
                        case "System.String"://字符串类型
                            newCell.SetCellValue(drValue);
                            break;
                        case "System.DateTime"://日期类型
                            DateTime dateV;
                            DateTime.TryParse(drValue, out dateV);
                            newCell.SetCellValue(dateV);
                            newCell.CellStyle = dateStyle;//格式化显示
                            break;
                        case "System.Boolean"://布尔型
                            bool boolV = false;
                            bool.TryParse(drValue, out boolV);
                            newCell.SetCellValue(boolV);
                            break;
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                        case "System.Byte":
                            int intV=0;
                            int.TryParse(drValue,out intV);
                            newCell.SetCellValue(intV);
                            break;
                        case "System.Decimal":
                        case "System.Double":
                            double doubV=0;
                            double.TryParse(drValue,out doubV);
                            newCell.SetCellValue(doubV);
                            break;
                        case "System.DBNull"://空值处理
                            newCell.SetCellValue("");
                            break;
                        default:
                           newCell.SetCellValue("");
                            break;
                    }
                }
                #endregion
                rowIndex++;
            }
            using(MemoryStream ms=new MemoryStream())
            {
                workbook.Write(ms);
                ms.Flush();
                ms.Position=0;
                return ms;
            }
        }
        /// <summary>
        /// DaataTable 导出到 Excel 文件
        /// </summary>
        /// <param name="dtSource">源 DataaTable</param>
        /// <param name="strHeaderText">表头文本</param>
        /// <param name="strFileName">保存位置(文件名及路径)</param>
        public static void ExportExcel(DataTable dtSource, string strHeaderText,string strFileName)
        {
            using (MemoryStream ms = ExportExcel(dtSource, strHeaderText))
            { 
                 using(FileStream fs=new FileStream(strFileName,FileMode.Create,FileAccess.Write))
                 {
                   byte[] data=ms.ToArray();
                     fs.Write(data,0,data.Length);
                     fs.Flush();
                 }
            }
        }

        /// <summary>
        /// 读取 excel
        /// 默认第一行为标头
        /// </summary>
        /// <param name="strFileName">excel 文档路径</param>
        /// <returns></returns>
        public static DataTable ImportExcel(string strFileName)
        {
            int ii = strFileName.LastIndexOf(".");
            string filetype = strFileName.Substring(ii + 1, strFileName.Length - ii - 1);
            DataTable dt = new DataTable();
            ISheet sheet;
            if ("xlsx" == filetype)
            {
                XSSFWorkbook xssfworkbook;
                using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
                {
                    xssfworkbook = new XSSFWorkbook(file);
                }
                sheet = xssfworkbook.GetSheetAt(0);
            }
            else
            {
                HSSFWorkbook hssfworkbook;
                using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
                {
                    hssfworkbook = new HSSFWorkbook(file);
                }
                sheet = hssfworkbook.GetSheetAt(0);
            }
            System.Collections.IEnumerator rows = sheet.GetRowEnumerator();
            IRow headerRow = sheet.GetRow(0);
            int cellCount = headerRow.LastCellNum;
            for (int j = 0; j < cellCount; j++)
            {
                ICell cell = headerRow.GetCell(j);
                dt.Columns.Add(cell.ToString());
            }
            for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++)
            {
                IRow row = sheet.GetRow(i);
                if (row.GetCell(row.FirstCellNum) != null && row.GetCell(row.FirstCellNum).ToString().Length > 0)
                {
                    DataRow dataRow = dt.NewRow();
                    for (int j = row.FirstCellNum; j < cellCount; j++)
                    {
                        if (row.GetCell(j) != null)
                        {

                            dataRow[j] = row.GetCell(j).ToString();

                        }
                    }
                    dt.Rows.Add(dataRow);
                }
            }
            return dt;

        }


        /// <summary>
        /// DataSet 导出到 Excel 的 MemoryStream
        /// </summary>
        /// <param name="dsSource">源 DataSet</param>
        /// <param name="strHeaderText">表头文本 空值未不要表头标题(多个表对应多个表头以英文逗号(,)分开，个数应与表相同)</param>
        /// <returns></returns>
        public static MemoryStream ExportExcel(DataSet dsSource, string strHeaderText)
        {

            HSSFWorkbook workbook = new HSSFWorkbook();
           
            #region 文件属性
            DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
            dsi.Company = "yuebon.com";
            workbook.DocumentSummaryInformation = dsi;
            SummaryInformation si = PropertySetFactory.CreateSummaryInformation();
            si.Author = "yuebon.com";
            si.ApplicationName = "yuebon.com";
            si.LastAuthor = "yuebon.com";
            si.Comments = "";
            si.Title = "";
            si.Subject = "";
            si.CreateDateTime = DateTime.Now;
            workbook.SummaryInformation = si;
            #endregion

            #region 注释


            //ICellStyle dateStyle = workbook.CreateCellStyle();
            //IDataFormat format = workbook.CreateDataFormat();
            //dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");

            //ISheet sheet = workbook.CreateSheet();
            //int[] arrColWidth = new int[dtSource.Columns.Count];
            //foreach (DataColumn item in dtSource.Columns)
            //{
            //    arrColWidth[item.Ordinal] = Encoding.GetEncoding("gb2312").GetBytes(item.ColumnName.ToString()).Length;
            //}
            //for (int i = 0; i < dtSource.Rows.Count; i++)
            //{
            //    for (int j = 0; j < dtSource.Columns.Count; j++)
            //    {
            //        int intTemp = Encoding.GetEncoding("gb2312").GetBytes(dtSource.Rows[i][j].ToString()).Length;
            //        if (intTemp > arrColWidth[j])
            //        {
            //            arrColWidth[j] = intTemp;
            //        }
            //    }
            //}
            //int rowIndex = 0;
            //int intTop = 0;
            //foreach (DataRow row in dtSource.Rows)
            //{
            //    #region 新建表、填充表头、填充列头，样式
            //    if (rowIndex == 65535 || rowIndex == 0)
            //    {
            //        if (rowIndex != 0)
            //        {
            //            sheet = workbook.CreateSheet();
            //        }
            //        intTop = 0;
            //        #region 表头及样式
            //        {
            //            if (strHeaderText.Length > 0)
            //            {
            //                IRow headerRow = sheet.CreateRow(intTop);
            //                intTop += 1;
            //                headerRow.HeightInPoints = 25;
            //                headerRow.CreateCell(0).SetCellValue(strHeaderText);
            //                ICellStyle headStyle = workbook.CreateCellStyle();
            //                headStyle.Alignment = HorizontalAlignment.CENTER;
            //                IFont font = workbook.CreateFont();
            //                font.FontHeightInPoints = 20;
            //                font.Boldweight = 700;
            //                headStyle.SetFont(font);
            //                headerRow.GetCell(0).CellStyle = headStyle;
            //                sheet.AddMergedRegion(new NPOI.SS.Util.CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));

            //            }
            //        }
            //        #endregion
            //        #region  列头及样式
            //        {
            //            IRow headerRow = sheet.CreateRow(intTop);
            //            intTop += 1;
            //            ICellStyle headStyle = workbook.CreateCellStyle();
            //            headStyle.Alignment = HorizontalAlignment.CENTER;
            //            IFont font = workbook.CreateFont();
            //            font.Boldweight = 700;
            //            headStyle.SetFont(font);
            //            foreach (DataColumn column in dtSource.Columns)
            //            {
            //                headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
            //                headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
            //                //设置列宽
            //                sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256);
            //            }


            //        }
            //        #endregion
            //        rowIndex = intTop;
            //    }
            //    #endregion
            //    #region 填充内容
            //    IRow dataRow = sheet.CreateRow(rowIndex);
            //    foreach (DataColumn column in dtSource.Columns)
            //    {
            //        ICell newCell = dataRow.CreateCell(column.Ordinal);
            //        string drValue = row[column].ToString();
            //        switch (column.DataType.ToString())
            //        {
            //            case "System.String"://字符串类型
            //                newCell.SetCellValue(drValue);
            //                break;
            //            case "System.DateTime"://日期类型
            //                DateTime dateV;
            //                DateTime.TryParse(drValue, out dateV);
            //                newCell.SetCellValue(dateV);
            //                newCell.CellStyle = dateStyle;//格式化显示
            //                break;
            //            case "System.Boolean"://布尔型
            //                bool boolV = false;
            //                bool.TryParse(drValue, out boolV);
            //                newCell.SetCellValue(boolV);
            //                break;
            //            case "System.Int16":
            //            case "System.Int32":
            //            case "System.Int64":
            //            case "System.Byte":
            //                int intV = 0;
            //                int.TryParse(drValue, out intV);
            //                newCell.SetCellValue(intV);
            //                break;
            //            case "System.Decimal":
            //            case "System.Double":
            //                double doubV = 0;
            //                double.TryParse(drValue, out doubV);
            //                newCell.SetCellValue(doubV);
            //                break;
            //            case "System.DBNull"://空值处理
            //                newCell.SetCellValue("");
            //                break;
            //            default:
            //                newCell.SetCellValue("");
            //                break;
            //        }
            //    }
            //    #endregion
            //    rowIndex++;
            //}
            #endregion

            string[] strNewText = strHeaderText.Split(Convert.ToChar(","));
            if (dsSource.Tables.Count == strNewText.Length) 
            {
                for(int i=0;i<dsSource.Tables.Count;i++)
                {
                    ExportFromDSExcel(workbook, dsSource.Tables[i], strNewText[i]);
                }
            }

            using (MemoryStream ms = new MemoryStream())
            {
                workbook.Write(ms);
                ms.Flush();
                ms.Position = 0;
                return ms;
            }
        }
         /// <summary>
        /// DataTable 导出到 Excel 的 MemoryStream
        /// </summary>
        /// <param name="workbook">源 workbook</param>
        /// <param name="dtSource">源 DataTable</param>
        /// <param name="strHeaderText">表头文本 空值未不要表头标题(多个表对应多个表头以英文逗号(,)分开，个数应与表相同)</param>
        /// <returns></returns>
        public static void ExportFromDSExcel(HSSFWorkbook workbook, DataTable dtSource, string strHeaderText)
        {
            ICellStyle dateStyle = workbook.CreateCellStyle();
            IDataFormat format = workbook.CreateDataFormat();
            dateStyle.DataFormat = format.GetFormat("yyyy-MM-dd HH:mm:ss");
            ISheet sheet = workbook.CreateSheet(strHeaderText);
            
            int[] arrColWidth = new int[dtSource.Columns.Count];
            foreach (DataColumn item in dtSource.Columns)
            {
                arrColWidth[item.Ordinal] = Encoding.GetEncoding("gb2312").GetBytes(item.ColumnName.ToString()).Length;
            }
            for (int i = 0; i < dtSource.Rows.Count; i++)
            {
                for (int j = 0; j < dtSource.Columns.Count; j++)
                {
                    int intTemp = Encoding.GetEncoding("gb2312").GetBytes(dtSource.Rows[i][j].ToString()).Length;
                    if (intTemp > arrColWidth[j])
                    {
                        arrColWidth[j] = intTemp;
                    }
                }
            }
            int rowIndex = 0;
            int intTop = 0;
            foreach (DataRow row in dtSource.Rows)
            {
                #region 新建表、填充表头、填充列头，样式
                if (rowIndex == 65535 || rowIndex == 0)
                {
                    if (rowIndex != 0)
                    {
                        sheet = workbook.CreateSheet();
                    }
                    intTop = 0;
                    #region 表头及样式
                    {
                        if (strHeaderText.Length > 0)
                        {
                            IRow headerRow = sheet.CreateRow(intTop);
                            intTop += 1;
                            headerRow.HeightInPoints = 25;
                            headerRow.CreateCell(0).SetCellValue(strHeaderText);
                            ICellStyle headStyle = workbook.CreateCellStyle();
                            headStyle.Alignment = HorizontalAlignment.Center;
                            IFont font = workbook.CreateFont();
                            font.FontHeightInPoints = 20;
                            font.Boldweight = 700;
                            headStyle.SetFont(font);
                            headerRow.GetCell(0).CellStyle = headStyle;
                            sheet.AddMergedRegion(new NPOI.SS.Util.CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));

                        }
                    }
                    #endregion
                    #region  列头及样式
                    {
                        IRow headerRow = sheet.CreateRow(intTop);
                        intTop += 1;
                        ICellStyle headStyle = workbook.CreateCellStyle();
                        headStyle.Alignment = HorizontalAlignment.Center;
                        IFont font = workbook.CreateFont();
                        font.Boldweight = 700;
                        headStyle.SetFont(font);
                        foreach (DataColumn column in dtSource.Columns)
                        {
                            headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
                            headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
                            //设置列宽
                            // sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256); // 设置设置列宽 太长会报错 修改2014 年9月22日
                            int  dd=(arrColWidth[column.Ordinal] + 1) * 256;

                            if (dd > 200 * 256)
                            {
                                dd = 100 * 256;
                            }


                            sheet.SetColumnWidth(column.Ordinal, dd);
                        }


                    }
                    #endregion
                    rowIndex = intTop;
                }
                #endregion
                #region 填充内容
                IRow dataRow = sheet.CreateRow(rowIndex);
                foreach (DataColumn column in dtSource.Columns)
                {
                    ICell newCell = dataRow.CreateCell(column.Ordinal);
                    string drValue = row[column].ToString();
                    switch (column.DataType.ToString())
                    {
                        case "System.String"://字符串类型
                            newCell.SetCellValue(drValue);
                            break;
                        case "System.DateTime"://日期类型
                            if (drValue.Length > 0)
                            {
                                DateTime dateV;
                                DateTime.TryParse(drValue, out dateV);
                                newCell.SetCellValue(dateV);
                                newCell.CellStyle = dateStyle;//格式化显示
                            }
                            else { newCell.SetCellValue(drValue); }
                            break;
                        case "System.Boolean"://布尔型
                            bool boolV = false;
                            bool.TryParse(drValue, out boolV);
                            newCell.SetCellValue(boolV);
                            break;
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                        case "System.Byte":
                            int intV = 0;
                            int.TryParse(drValue, out intV);
                            newCell.SetCellValue(intV);
                            break;
                        case "System.Decimal":
                        case "System.Double":
                            double doubV = 0;
                            double.TryParse(drValue, out doubV);
                            newCell.SetCellValue(doubV);
                            break;
                        case "System.DBNull"://空值处理
                            newCell.SetCellValue("");
                            break;
                        default:
                            newCell.SetCellValue("");
                            break;
                    }
                }
                #endregion
                rowIndex++;
            }
        }

        /// <summary>
        /// 按指定长度创建列并带入样式
        /// </summary>
        /// <param name="hssfrow"></param>
        /// <param name="len"></param>
        /// <param name="cellstyle"></param>
        /// <returns></returns>
        public static bool CreateCellsWithLength(XSSFRow hssfrow, int len, XSSFCellStyle cellstyle)
        {
            try
            {
                for (int i = 0; i < len; i++)
                {
                    hssfrow.CreateCell(i);
                    hssfrow.Cells[i].CellStyle = cellstyle;
                }
                return true;
            }
            catch (Exception ce)
            {
                throw new Exception("CreateCellsWithLength:" + ce.Message);
            }
        }

    }
}

*
*
*

C# asp.net MVC Excel导入导出Dome 注释明确 清楚明了
04-27
Excel导入导出，并详细讲解上传 是如何安装步骤 将文件上传到服务器 然后进行一个解读文件 进行数据插入数据库，最后将文件删除：可根据项目情况自行调解
ASP.NET MVC表格数据的导入导出
weixin_46244925的博客
08-09 731
ASP.NET MVC 课程： MVC项目中表格数据的导入导出操作： 一：表格（excel）数据导出：利用了浏览器的文件下载功能，一般都是在新页面打开下载的url(https://blog.csdn.net/%E4%BE%8B%E5%A6%82%EF%BC%9Awindow%3Cem%3E.%3C/em%3Eopen()????。再转到控制器查询出需要导出的数据，由于c#不支持直接进行excel操作，只能由第三方组建：第一种：微软的msoffice excel,缺点：使用者office版本必须与开发者电脑版本一致；一般使用第二种：NPOI（JAVA POI）库中XIS。 1.项目添加引用NPOI 2.第一种NPOI导出Excel
(原创)datagrid数据导出到excel文件给客户端下载的几种方法
03-12 6952
方法一：导出到csv文件，存放在服务器端任一路径，然后给客户下载优点：1、可以进行身份认证后给客户下载，如果放到非web目录就没有对应的url，客户无法随时下载。2、也是因为生成了文件，所以占用了服务器的空间，但是可以把文件名存放到数据库，再次给客户下载的时候不需要重复生成文件。3、csv文件是文本文件，逗号隔开字段，回车隔开行，易于数据导入导出。实现方法：   SqlConnection con
告别繁琐！用VS2022 Installer Projects给WinForm程序做个专业安装包（含卸载功能）
最新发布
weixin_30342209的博客
05-16 380
本文详细介绍了如何使用VS2022的Installer Projects扩展为WinForm程序创建专业安装包，包含自动依赖检测、桌面快捷方式、自定义图标和完整卸载功能。通过实战指南，开发者可以轻松实现商业级软件分发，告别手动配置的繁琐过程。
c#MVC汇出Excel的三种方法
yuanqi3131的博客
08-07 1681
初学C#，入职不久，公司考核项目，其中就有将同比环比数据导出Excel,网上找了很多的例子，非常头痛，所以发誓自己写完了就吧所有的集中在一起，当然参照了很多博客，其中一篇有三种方法，想引入进来，但是忘记地址了，万分抱歉，闲话少说 1.第一种 IO流 两个参数 TranDate, BranchCode 一个为时间，一个为分店号，我是用这两个参数获取数据的，主要获取DataTable,按你自己的方...
.Net查询结果下载成Excel（HSSFWorkbook）
meimumu的博客
11-30 545
.Net查询结果下载成Excel（HSSFWorkbook），不需要模板。
ASP.NET MVC结合NPOI实现Excel导出功能
weixin_42598278的博客
09-16 1154
在现代企业级Web应用中，数据的可视化呈现和批量导出已成为不可或缺的功能模块。尤其是在报表生成、财务系统、人力资源管理等场景下，将数据库中的结构化数据以Excel文件形式导出，不仅便于用户查看与分析，也支持进一步的数据处理。然而，在不依赖Office组件的前提下实现高效、稳定、跨平台的Excel操作，一直是开发者面临的技术挑战。NPOI作为.NET平台上最受欢迎的开源Excel读写库之一，凭借其对多种Excel格式的支持、良好的性能表现以及丰富的API设计，成为解决这一问题的核心工具。
在.NET MVC中使用NPOI库实现内存流导出Excel文件指南
weixin_35516273的博客
05-17 784
在构建现代Web应用程序时，选择一个合适的架构模式至关重要。.NET MVC，即Model-View-Controller，是微软公司设计的一种框架，用于帮助开发者高效地开发可维护和可扩展的Web应用。该架构强调了关注点分离的原则，通过清晰的分层来确保代码的组织性和模块化，促进了开发团队间的协作。NPOI是一个开源的.NET库，允许开发者在.NET应用程序中读取和写入Microsoft Office格式的文件，包括但不限于Excel、Word和PowerPoint。
C# ASP.NET MVC Excel导入导出实例详解
weixin_42510243的博客
08-23 382
ASP.NET MVC是微软公司开发的一套基于模型-视图-控制器（Model-View-Controller，MVC）设计模式的Web应用程序框架。它旨在提供一种更灵活的方式来构建动态网站，让开发者可以更容易地分离关注点（关注点分离），并进行单元测试。EPPlus库提供了非常直观的API用于读写Excel文件，可以通过以下代码段展示如何读取Excel文件：// 获取第一个工作表// 获取第2行第2列的单元格// 读取单元格的值写入Excel文件的示例：// 添加一个工作表。
使用C#在ASP.NET中导出Excel教程
weixin_28933797的博客
08-07 961
EPPlus 是一个开源的 .NET 库，它允许开发者在 ASP.NET 或 Windows 应用程序中轻松地操作 Excel 文件。它支持创建和编辑 Excel 2007 以上版本的文件（扩展名为 .xlsx），并且可以处理大量数据，同时保持文件大小的合理性和操作的高效性。EPPlus 提供了丰富的接口用于直接读写 Excel 工作表的内容、格式和属性。EPPlus 的几个显著特点包括：易于使用：代码简洁，直观，易于集成到 ASP.NET MVC 或 Web API 应用程序中。
spring mvc利用poi实现Excel文件下载、上传
weixin_44728473的博客
12-12 1387
注意前端也需要进行设置： processData:false,//设置ajax向后台提交参数之前，是否把参数统一转换成字符串：true–是,false–不是,默认是true。contentType:false,//设置ajax向后台提交参数之前，是否把所有的参数统一按urlencoded编码：true–是,false–不是，默认是true。2.springmvc配置信息。3.excel文件操作的工具类。
ASP.NET MVC中导出Excel的方式(一）（使用创作助手生成）
木木狐工作室
09-13 1141
在这个示例中，我们首先创建了一个ClosedXML工作簿，添加了一个工作表，设置表头和数据，并调整了每列的宽度。然后我们设置响应头信息，将Excel文件写入响应流，并将ActionResult返回为空。在这个示例中，我们首先创建了一个Excel包，添加了一个工作表，设置表头和数据，并使用自适应列宽自动调整列宽。然后我们设置响应头信息，将Excel文件写入响应流，并将ActionResult返回为空。两种方式都能轻松地在ASP.NET MVC中生成Excel文件，并将其作为响应发送给请求方。
.net core mvc 导出excel文件 并且下载
代码笔记
09-25 2394
.net core mvc 导出excel文件 并且下载， 支持Excel样式调整：表格线、黑体表头、列宽、垂直对齐....
C#、MVC的利用NPOI的Excel数据导出
weixin_47316183的博客
08-10 887
MVC中Excel表格数据导出： 第一种：在已有的模板上导出数据（前提是构建好模板） 第二种：正常的导出数据 第三种：含有合并表头的的数据导出 不管是哪一种，数据导出都是建立在NPOI插件基础上的，都需要先将NPOI放入到项目中bin文件夹里面，然后添加引用 含有合并表头的数据导出： 整体思路：先创建好工作簿，然后在该工作簿中创建工作表。然后在工作表中创建第一行，接着在第一行创建单元格，然后给这个单元格设置样式、内容，需要注意的是：因为是合并表头，所以需要合并单元格。 然后接着在工作表中创建表头行，因为合并
ASP.NET MVC 导入Excel表格中的数据至数据库
weixin_45721343的博客
01-09 2547
ASP.NET MVC 导入Excel表格中的数据至数据库 1.导入工具类（ImportExcel.cs） public class ImportExcel { public static DataTable GetExcelDataTable(string filePath) { IWorkbook Workbook; ...
MVC之Excel导出表格数据
weixin_44543135的博客
06-28 845
MVC之Excel导出表格数据 第一步：先把Excel导出的插件（NPOI）引用进来； 第二步：然后通过linq语句查询出需要导出的数据表\集合（list），当然前提是你有引用了数据库实体模型，并实例化了数据库实体; 例如： 在当前类下面实例化实体 Models.GZJSJEntities myModels = new Models.GZJSJEntities(); 然后创建一个导出数据的方法，通...
.NET MVC：实现导出Excel表格
weixin_54629917的博客
06-18 1710
MVC 使用NPOI导出Excel表格
ASP.NET MVC中如何实现Excel数据的导出导入
m0_56259289的博客
07-15 1812
ASP.NET MVC中NPOI的使用，实现Excel数据的导出导入
.net下载到本地为excel格式
qq_45244974的博客
12-22 554
接口: public ActionResult DemoPostDownLoad() { var caseid = (string)Session["CaseId"]; var companyId = (string)Session["CompanyId"]; var demoPost = new List<DemoPostAndAge>(); IWorkbook workboo
ASP.NET MVC的Excel工作簿导入
weixin_44550157的博客
04-14 1154
ASP.NET MVC的Excel工作簿导入 开发工具与关键技术：VS/MVC 作者：何桂朋 撰写时间：2019年4月11日 我认为ASP.NET MVC中，Microsoft Excel 工作表导入数据库，需要以下五步： 1、确定选中的是Excel表 2、确定Excel表有工作表（需要引用NPOI插件） 3、确定Excel表的表头数据是否与接收的表的字段名称对应(即是确定数据的准确性) 4、保存...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值