.NET Core6.0使用NPOI导入导出Excel

已于 2023-08-17 14:38:03 修改
阅读量2.6k 收藏 6
点赞数
文章标签： .net core
于 2023-08-16 11:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43005276/article/details/132312970
版权

一、使用NPOI导出Excel
//引入NPOI包
在这里插入图片描述

  • HTML
<input type="button" class="layui-btn layui-btn-blue2 layui-btn-sm" id="ExportExcel" onclick="ExportExcel()" value="导出" />
  • JS
    //导出Excel
    function ExportExcel() {
        window.location.href = "@Url.Action("ExportFile")";
    }
  • C#
 private readonly Microsoft.AspNetCore.Hosting.IHostingEnvironment _hostingEnvironment;
 public HomeController(Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment)
        {
            _hostingEnvironment = hostingEnvironment;
        }


        [HttpGet("ExportFile")]
        //导出文件
        public async Task<IActionResult> ExportFile()
        {
            //获取数据库数据
            var result = await _AnsweringQuestion.GetTeacherName();
            string filePath = "";
            //获取文件路径和名称
            var wwwroot = _hostingEnvironment.WebRootPath;
            var filename = "Table.xlsx";
            filePath = Path.Combine(wwwroot, filename);
            //创建一个工作簿和工作表
            NPOI.XSSF.UserModel.XSSFWorkbook book = new NPOI.XSSF.UserModel.XSSFWorkbook();
            var sheet = book.CreateSheet();
            //创建表头行
            var headerRow = sheet.CreateRow(0);
            headerRow.CreateCell(0).SetCellValue("姓名");
            headerRow.CreateCell(1).SetCellValue("科目");
            headerRow.CreateCell(2).SetCellValue("说明");
            //创建数据行
            var data = result.DataList;
            for (int i = 0; i < data.Count(); i++)
            {
                var dataRow = sheet.CreateRow(i + 1);
                dataRow.CreateCell(0).SetCellValue(data[i].TeacherName);
                dataRow.CreateCell(1).SetCellValue(data[i].TeachSubject); 
                dataRow.CreateCell(2).SetCellValue(data[i].TeacherDesc);
            }
            //将Execel 文件写入磁盘
            using (var f = System.IO.File.OpenWrite(filePath))
            {
                book.Write(f);
            }
            //将Excel 文件作为下载返回给客户端
            var bytes = System.IO.File.ReadAllBytes(filePath);
            return File(bytes, "application/octet-stream", $"{System.DateTime.Now.ToString("yyyyMMdd")}.xlsx");
        }

二、使用NPOI导入Excel

  • HTML
 <input type="button" class="layui-btn layui-btn-blue2 layui-btn-sm" id="Excel" value="导入" />
  • JS
    <script>
    /*从本地添加excel文件方法*/
    layui.use('upload', function () {
        var $ = layui.jquery
            , upload = layui.upload
            , form = layui.form;
        upload.render({
            elem: '#Excel'//附件上传按钮ID
            , url: '/Home/ImportFile'//附件上传后台地址
            , multiple: true
            , accept: 'file'
            , exts: 'xls|xlsx'//(允许的类别)
            , before: function (obj) {/*上传前执行的部分*/ }
            , done: function excel(res) {
                console.log(res);
            }
            , allDone: function (res) {
            console.log(res);
            }
        });
    });//上传事件结束
</script>
  • C#
  • 控制器代码
        //注入依赖
        private readonly Microsoft.AspNetCore.Hosting.IHostingEnvironment _hostingEnvironment;
        public HomeController(Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment)
        {
            _hostingEnvironment = hostingEnvironment;
        }
        //控制器
         /// <summary>
        /// 导入
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>

        [RequestSizeLimit(524288000)]  //文件大小限制
        [HttpPost]
        public async Task<IActionResult> ImportFile(IFormFile file)
        {
            //把文件保存到文件夹下
            var path = "wwwroot/" + file.FileName;
            using (FileStream files = new FileStream(path, FileMode.OpenOrCreate))
            {
                file.CopyTo(files);
            }
            var wwwroot = _hostingEnvironment.WebRootPath;
            var fileSrc = wwwroot+"\\"+ file.FileName;
            List<UserEntity> list = new ExcelHelper<UserEntity>().ImportFromExcel(fileSrc);
            //取到数据后，接下来写你的业务逻辑就可以了
            for (int i = 0; i < list.Count; i++)
            {
                var Name = string.IsNullOrEmpty(list[i].Name.ToString())? "" : list[i].Name.ToString();
                var Age = string.IsNullOrEmpty(list[i].Age.ToString()) ? "" : list[i].Age.ToString();
                var Gender = string.IsNullOrEmpty(list[i].Gender.ToString()) ? "" : list[i].Gender.ToString();
                var Tel = string.IsNullOrEmpty(list[i].Tel.ToString()) ? "" : list[i].Tel.ToString();

            }

            return Ok(new { Msg = "导入成功", Code = 200});
        }
  • 添加ExcelHelper类
using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using System.Collections.Concurrent;
using System.ComponentModel;
using System.Reflection;

namespace NetCore6Demo.Models
{
    public class ExcelHelper<T> where T : new()
    {
        #region Excel导入
        /// <summary>
        /// Excel导入
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public List<T> ImportFromExcel(string FilePath)
        {
            List<T> list = new List<T>();
            HSSFWorkbook hssfWorkbook = null;
            XSSFWorkbook xssWorkbook = null;
            ISheet sheet = null;
            using (FileStream file = new FileStream(FilePath, FileMode.Open, FileAccess.Read))
            {
                switch (Path.GetExtension(FilePath))
                {
                    case ".xls":
                        hssfWorkbook = new HSSFWorkbook(file);
                        sheet = hssfWorkbook.GetSheetAt(0);
                        break;

                    case ".xlsx":
                        xssWorkbook = new XSSFWorkbook(file);
                        sheet = xssWorkbook.GetSheetAt(0);
                        break;

                    default:
                        throw new Exception("不支持的文件格式");
                }
            }
            IRow columnRow = sheet.GetRow(0); //第1行为字段名
            Dictionary<int, PropertyInfo> mapPropertyInfoDict = new Dictionary<int, PropertyInfo>();
            for (int j = 0; j < columnRow.LastCellNum; j++)
            {
                ICell cell = columnRow.GetCell(j);
                PropertyInfo propertyInfo = MapPropertyInfo(cell.ParseToString());
                if (propertyInfo != null)
                {
                    mapPropertyInfoDict.Add(j, propertyInfo);
                }
            }

            for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++)
            {
                IRow row = sheet.GetRow(i);
                T entity = new T();
                for (int j = row.FirstCellNum; j < columnRow.LastCellNum; j++)
                {
                    if (mapPropertyInfoDict.ContainsKey(j))
                    {
                        if (row.GetCell(j) != null)
                        {
                            PropertyInfo propertyInfo = mapPropertyInfoDict[j];
                            switch (propertyInfo.PropertyType.ToString())
                            {
                                case "System.DateTime":
                                case "System.Nullable`1[System.DateTime]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToDateTime());
                                    break;

                                case "System.Boolean":
                                case "System.Nullable`1[System.Boolean]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToBool());
                                    break;

                                case "System.Byte":
                                case "System.Nullable`1[System.Byte]":
                                    mapPropertyInfoDict[j].SetValue(entity, Byte.Parse(row.GetCell(j).ParseToString()));
                                    break;
                                case "System.Int16":
                                case "System.Nullable`1[System.Int16]":
                                    mapPropertyInfoDict[j].SetValue(entity, Int16.Parse(row.GetCell(j).ParseToString()));
                                    break;
                                case "System.Int32":
                                case "System.Nullable`1[System.Int32]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToInt());
                                    break;

                                case "System.Int64":
                                case "System.Nullable`1[System.Int64]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToLong());
                                    break;

                                case "System.Double":
                                case "System.Nullable`1[System.Double]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToDouble());
                                    break;

                                case "System.Single":
                                case "System.Nullable`1[System.Single]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToDouble());
                                    break;

                                case "System.Decimal":
                                case "System.Nullable`1[System.Decimal]":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString().ParseToDecimal());
                                    break;

                                default:
                                case "System.String":
                                    mapPropertyInfoDict[j].SetValue(entity, row.GetCell(j).ParseToString());
                                    break;
                            }
                        }
                    }
                }
                list.Add(entity);
            }
            hssfWorkbook?.Close();
            xssWorkbook?.Close();
            return list;
        }



        /// <summary>
        /// 查找Excel列名对应的实体属性
        /// </summary>
        /// <param name="columnName"></param>
        /// <returns></returns>
        private PropertyInfo MapPropertyInfo(string columnName)
        {
            PropertyInfo[] propertyList = GetProperties(typeof(T));
            PropertyInfo propertyInfo = propertyList.Where(p => p.Name == columnName).FirstOrDefault();
            if (propertyInfo != null)
            {
                return propertyInfo;
            }
            else
            {
                foreach (PropertyInfo tempPropertyInfo in propertyList)
                {
                    DescriptionAttribute[] attributes = (DescriptionAttribute[])tempPropertyInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (attributes.Length > 0)
                    {
                        if (attributes[0].Description == columnName)
                        {
                            return tempPropertyInfo;
                        }
                    }
                }
            }
            return null;
        }

        private static ConcurrentDictionary<string, object> dictCache = new ConcurrentDictionary<string, object>();
        #region 得到类里面的属性集合
        /// <summary>
        /// 得到类里面的属性集合
        /// </summary>
        /// <param name="type"></param>
        /// <param name="columns"></param>
        /// <returns></returns>
        public static PropertyInfo[] GetProperties(Type type, string[] columns = null)
        {
            PropertyInfo[] properties = null;
            if (dictCache.ContainsKey(type.FullName))
            {
                properties = dictCache[type.FullName] as PropertyInfo[];
            }
            else
            {
                properties = type.GetProperties();
                dictCache.TryAdd(type.FullName, properties);
            }

            if (columns != null && columns.Length > 0)
            {
                //  按columns顺序返回属性
                var columnPropertyList = new List<PropertyInfo>();
                foreach (var column in columns)
                {
                    var columnProperty = properties.Where(p => p.Name == column).FirstOrDefault();
                    if (columnProperty != null)
                    {
                        columnPropertyList.Add(columnProperty);
                    }
                }
                return columnPropertyList.ToArray();
            }
            else
            {
                return properties;
            }
        }
        #endregion


        #endregion
    }
}
  • 添加Extensions类
 public static partial class Extensions
    {
        #region 转换为long
        /// <summary>
        /// 将object转换为long，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static long ParseToLong(this object obj)
        {
            try
            {
                return long.Parse(obj.ToString());
            }
            catch
            {
                return 0L;
            }
        }

        /// <summary>
        /// 将object转换为long，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static long ParseToLong(this string str, long defaultValue)
        {
            try
            {
                return long.Parse(str);
            }
            catch
            {
                return defaultValue;
            }
        }
        #endregion

        #region 转换为int
        /// <summary>
        /// 将object转换为int，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static int ParseToInt(this object str)
        {
            try
            {
                return Convert.ToInt32(str);
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 将object转换为int，若转换失败，则返回指定值。不抛出异常。 
        /// null返回默认值
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static int ParseToInt(this object str, int defaultValue)
        {
            if (str == null)
            {
                return defaultValue;
            }
            try
            {
                return Convert.ToInt32(str);
            }
            catch
            {
                return defaultValue;
            }
        }
        #endregion

        #region 转换为short
        /// <summary>
        /// 将object转换为short，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static short ParseToShort(this object obj)
        {
            try
            {
                return short.Parse(obj.ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 将object转换为short，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static short ParseToShort(this object str, short defaultValue)
        {
            try
            {
                return short.Parse(str.ToString());
            }
            catch
            {
                return defaultValue;
            }
        }
        #endregion

        #region 转换为demical
        /// <summary>
        /// 将object转换为demical，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static decimal ParseToDecimal(this object str, decimal defaultValue)
        {
            try
            {
                return decimal.Parse(str.ToString());
            }
            catch
            {
                return defaultValue;
            }
        }

        /// <summary>
        /// 将object转换为demical，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static decimal ParseToDecimal(this object str)
        {
            try
            {
                return decimal.Parse(str.ToString());
            }
            catch
            {
                return 0;
            }
        }
        #endregion

        #region 转化为bool
        /// <summary>
        /// 将object转换为bool，若转换失败，则返回false。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static bool ParseToBool(this object str)
        {
            try
            {
                return bool.Parse(str.ToString());
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 将object转换为bool，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static bool ParseToBool(this object str, bool result)
        {
            try
            {
                return bool.Parse(str.ToString());
            }
            catch
            {
                return result;
            }
        }
        #endregion

        #region 转换为float
        /// <summary>
        /// 将object转换为float，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static float ParseToFloat(this object str)
        {
            try
            {
                return float.Parse(str.ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 将object转换为float，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static float ParseToFloat(this object str, float result)
        {
            try
            {
                return float.Parse(str.ToString());
            }
            catch
            {
                return result;
            }
        }
        #endregion

        #region 转换为Guid
        /// <summary>
        /// 将string转换为Guid，若转换失败，则返回Guid.Empty。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static Guid ParseToGuid(this string str)
        {
            try
            {
                return new Guid(str);
            }
            catch
            {
                return Guid.Empty;
            }
        }
        #endregion

        #region 转换为DateTime
        /// <summary>
        /// 将string转换为DateTime，若转换失败，则返回日期最小值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static DateTime ParseToDateTime(this string str)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(str))
                {
                    return DateTime.MinValue;
                }
                if (str.Contains("-") || str.Contains("/"))
                {
                    return DateTime.Parse(str);
                }
                else
                {
                    int length = str.Length;
                    switch (length)
                    {
                        case 4:
                            return DateTime.ParseExact(str, "yyyy", System.Globalization.CultureInfo.CurrentCulture);
                        case 6:
                            return DateTime.ParseExact(str, "yyyyMM", System.Globalization.CultureInfo.CurrentCulture);
                        case 8:
                            return DateTime.ParseExact(str, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
                        case 10:
                            return DateTime.ParseExact(str, "yyyyMMddHH", System.Globalization.CultureInfo.CurrentCulture);
                        case 12:
                            return DateTime.ParseExact(str, "yyyyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture);
                        case 14:
                            return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
                        default:
                            return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
                    }
                }
            }
            catch
            {
                return DateTime.MinValue;
            }
        }

        /// <summary>
        /// 将string转换为DateTime，若转换失败，则返回默认值。  
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static DateTime ParseToDateTime(this string str, DateTime? defaultValue)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(str))
                {
                    return defaultValue.GetValueOrDefault();
                }
                if (str.Contains("-") || str.Contains("/"))
                {
                    return DateTime.Parse(str);
                }
                else
                {
                    int length = str.Length;
                    switch (length)
                    {
                        case 4:
                            return DateTime.ParseExact(str, "yyyy", System.Globalization.CultureInfo.CurrentCulture);
                        case 6:
                            return DateTime.ParseExact(str, "yyyyMM", System.Globalization.CultureInfo.CurrentCulture);
                        case 8:
                            return DateTime.ParseExact(str, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
                        case 10:
                            return DateTime.ParseExact(str, "yyyyMMddHH", System.Globalization.CultureInfo.CurrentCulture);
                        case 12:
                            return DateTime.ParseExact(str, "yyyyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture);
                        case 14:
                            return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
                        default:
                            return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
                    }
                }
            }
            catch
            {
                return defaultValue.GetValueOrDefault();
            }
        }
        #endregion

        #region 转换为string
        /// <summary>
        /// 将object转换为string，若转换失败，则返回""。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ParseToString(this object obj)
        {
            try
            {
                if (obj == null)
                {
                    return string.Empty;
                }
                else
                {
                    return obj.ToString();
                }
            }
            catch
            {
                return string.Empty;
            }
        }
        public static string ParseToStrings<T>(this object obj)
        {
            try
            {
                var list = obj as IEnumerable<T>;
                if (list != null)
                {
                    return string.Join(",", list);
                }
                else
                {
                    return obj.ToString();
                }
            }
            catch
            {
                return string.Empty;
            }

        }
        #endregion

        #region 转换为double
        /// <summary>
        /// 将object转换为double，若转换失败，则返回0。不抛出异常。  
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static double ParseToDouble(this object obj)
        {
            try
            {
                return double.Parse(obj.ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 将object转换为double，若转换失败，则返回指定值。不抛出异常。  
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static double ParseToDouble(this object str, double defaultValue)
        {
            try
            {
                return double.Parse(str.ToString());
            }
            catch
            {
                return defaultValue;
            }
        }
        #endregion
    }
  • 添加实体类UserEntity,要跟Excel的列名一致
 public class UserEntity
    {
        [Description("名称")]
        public string Name { get; set; }
        [Description("年龄")]
        public string Age { get; set; }
        [Description("性别")]
        public string Gender { get; set; }
        [Description("手机号")]
        public string Tel { get; set; }
    }
  • Excel模板
    !https://img-blog.csdnimg.cn/5a79394d772c4c9ab0d28972f09f2f67.png)
  • 实现效果
    在这里插入图片描述
黒貓警长
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 导入导出Excel 使用NPOI
大佬的博客
11-16 441
c# 使用NPOI 导入导出Excel
在NET中使用NPOI导出Excel
我的梦想，我做主
07-16 4683
前段时间客户要求网页上显示的报表能导出成Excel文件，而且要求Excel有好看的样式，虽然导出Excel的方式很多，但是都达不到要求，后来在网上找到使用NPOI组件的方式导出，自己进行调试，发现完全可以达到要求，为了使用方便和客户以后的需求，自己写了几个类对NPOI提供的方法进
.Net core NPOI导入导出Excel
abxdd2015的博客
08-09 899
最近在想.net core NPOI 导入导出Excel，一开始感觉挺简单的，后来真的遇到很多坑。所以还是写一篇博客让其他人少走一些弯路，也方便忘记了再重温一遍。好了，多的不说，直接开始吧。 在.Net core 使用NPOI首先必须先安装DotNetCore.NPOI，第一种方法可以在管理Nuget包中安装，如图： 直接搜索DotNet.NPOI 安装就可以了。 第...
.Net Core WebAPI + Vue + Axios 导出 Excel / CSV 文件
辞仙
09-16 2115
这两种方法目前如果遇到0开头的数据，会默认把0去掉，可以考虑如果StartsWith(“0”)，则在前面加个单引号（即’） 不推荐Excel导出，因为Excel2003一个Sheet最多导出65535条，Excel2007是10万4000多条，数据量大会报错，所以推荐使用CSV导出 导出 Excel/// <summary> /// 将 DataTable 转换为 Excel /// 需在 nuget 安装 DotNetCore.NPOI /// </summary> /// .
.net core webapi 导出excel(两种方式EPPLUS、NPOI)，返回下载地址或文件流
热门推荐
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
02-21 1万+
.net core webapi 导出excel nuget安装 EPPlus.Core . 使用起来也很简单,我们构造 ExcelHelper 类，并在controller里面使用。 比如 person类有 id，name，age 3个属性，则 在controller里面这样调用 [Route("ExportExcel")] [HttpGet] public IActionRes...
.Net Core NPOI 导入导出Excel 完整
小白
01-05 2598
.Net Core NPOI 导入导出Excel 前言 NPOI也用了许久，经常会碰到导入导出Excel功能的需求，好记性不如烂笔头，记下导入导出流程。 导入Excel 导入Excel主要思想还是将数据取出以后填入DataTable，然后循环DataTable，插入库里： Controller Service 导出 导出将list内容取出，然后插入到对应单元格内 controller service ...
.NET Core使用NPOI实现Excel的导入导出
xll的博客
04-15 808
本篇文章将讲解如何在.NET Core项目中使用NPOI实现将数据库数据导出为Excel文件,以及如何将Excel文件内容导入到数据库.
.net 6简单使用NPOI 读取 Excel 案例+流程
二等碗
06-08 3195
平台：.net6 框架：DotNetCore.NPOI读取Excel 数据，使用了 NPOI 这个框架，这个框架NPOI是指构建在POI 3.x版本之上的一个程序，NPOI可以在没有安装Office的情况下对Word或Excel文档进行读写操作。创建新项目，我们选择控制台项目来做一个案例 配置新项目，这里项目写的名字是 NPOITest1 选择框架：（环境） .net 6在项目右键，找到管理 Nuget 并点击进入 nuget 管理1、点击“浏览” 2、输入NPOI 对框架进行搜索 3、选择 DotNet
Asp.Net使用Npoi导入导出Excel的方法
10-25
主要介绍了Asp.Net使用Npoi导入导出Excel的方法,采用该方法在导出Excel的时候不需要office组件的支持,而在导入Excel的时候采用OleDb的方式，需要office组件的支持。是一个非常实用的技巧,需要的朋友可以参考下
ASP.NET Core 导入导出Excel xlsx 文件实例
10-20
总的来说，通过使用EPPlus.Core，ASP.NET Core开发者可以轻松地处理Excel文件的导入导出任务，从而增强应用的数据处理能力。这使得开发人员能够与使用Excel的用户进行更紧密的合作，提高数据交换的效率。
通用ASP.NET Core NPOI导出复杂Word、Excel和Excel数据导入实战项目
09-08
3. **Excel数据导出**：在ASP.NET Core应用中，你可以将数据库中的数据导出为Excel文件供用户下载。这通常涉及数据查询、模型映射以及使用NPOI的`ISheet`和`IRow`接口创建工作表和行，设置单元格值。例如，可以创建...
【ASP.NET编程知识】Asp.Net使用Npoi导入导出Excel的方法.docx
05-18
"ASP.NET使用Npoi导入导出Excel的方法" 在ASP.NET编程中，导入和导出Excel文件是一种非常常见的功能。Npoi是一个开源的库，能够帮助开发者轻松地实现Excel文件的导入和导出。本文将详细介绍如何使用Npoi在ASP.NET中...
秃鹰算法BES优化Transformer-LSTM负荷数据回归预测【含Matlab源码 6405期】.zip
08-01
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化Transformer-LSTM预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化Transformer-LSTM预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化Transformer-LSTM预测 4.4.3 灰狼算法GWO/狼群算法WPA优化Transformer-LSTM预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化Transformer-LSTM预测 4.4.5 萤火虫算法FA/差分算法DE优化Transformer-LSTM预测 4.4.6 其他优化算法优化Transformer-LSTM预测
EtherCAT协议（中文版）完整1-6册
08-01
ETG1000_1_CHN_Overview_V1i0i2_C01 ETG1000_2_CHN_EcatPhysicalLayer_V1i0i2_C01 ETG1000_3_CHN_EcatDLLServices_V1i0i2_C01 ETG1000_4_CHN_EcatDLLServices_V1i0i2_C01 ETG1000_5_CHN_EcatALServices_V1i0i2_C01 ETG1000_6_CHN_EcatALProtocols_V1i0i2_C01 ETG1000_6_V1i0i3_S_R_EcatALProtocols
大数据中心建设方案.pptx
08-01
大数据中心建设方案.pptx
PHP开发神器：探索流行的PHP代码编辑器和IDE
08-01
PHP（Hypertext Preprocessor）是一种广泛使用的开源脚本语言，主要用于Web开发，将服务器端的脚本与HTML页面相结合，创建动态交互式Web页面。PHP的名字是一个递归缩写，表示"PHP: Hypertext Preprocessor"。 ## PHP的主要特点： 1. **服务器端脚本**：PHP代码在服务器上执行，生成HTML内容，然后发送给客户端浏览器显示。 2. **嵌入HTML**：PHP代码可以直接嵌入到HTML代码中，或者通过PHP标签包含在单独的文件中。 3. **强大的功能**：PHP提供了丰富的内置函数和库，支持多种数据库连接（如MySQL、PostgreSQL等），可以处理表单、文件上传、发送邮件等。 4. **跨平台**：PHP可以在多种操作系统上运行，包括Linux、Windows、macOS等。 5. **面向对象**：PHP支持面向对象编程（OOP），允许开发者创建类和对象。 6. **可扩展性**：PHP可以通过PECL扩展库来扩展其功能。 7. **社区支持**：PHP有一个庞大的开发者社区，提供大量的框架、工具和资源。 #
[毕业设计]JAVA实现SNMP协议对网络设备MIB库的访问与数据解析(源代码+论文).zip
08-01
[毕业设计]JAVA实现SNMP协议对网络设备MIB库的访问与数据解析(源代码+论文)
静态页面仿第五人格官网(简易版)
最新发布
08-01
静态页面仿第五人格官网(简易版)
wpf使用npoi导入导出excel
07-14
### 回答1： WPF是一种用于开发桌面应用程序的技术，而NPOI是一个用于处理Excel文件的开源库。通过结合使用WPF和NPOI，我们可以在WPF应用程序中实现Excel文件的导入和导出功能。 要使用NPOI导入Excel文件，首先需要引入NPOI库。我们可以通过NuGet包管理器将NPOI库添加到我们的WPF项目中。然后，我们可以使用NPOI的API来读取和解析Excel文件。我们需要创建一个Workbook对象，并选择要读取的特定Sheet，然后使用循环遍历每一行，并读取每个单元格的值。 在WPF中，我们可以创建一个界面并添加一个按钮，用于触发Excel文件导入功能。当用户点击按钮时，我们将使用NPOI库打开文件选择对话框，允许用户选择要导入的Excel文件。一旦我们获取了用户选择的文件路径，我们可以使用NPOI的API来读取Excel文件，然后将数据绑定到WPF应用程序中的相应控件上。 要使用NPOI导出Excel文件，在WPF中，我们可以将数据绑定到DataGrid或ListView等控件上。当用户点击导出按钮时，我们可以使用NPOI的API来创建一个Workbook对象，并选择要导出的Sheet。然后，我们可以使用循环遍历来将数据从WPF控件中导出到Excel文件的每一行。 最后，我们可以将导出的Excel文件保存到硬盘上的特定路径。使用NPOI的API，我们可以设置导出文件的格式和样式，例如设置单元格的字体、颜色、边框等。 总之，通过使用NPOI库，我们可以在WPF应用程序中实现Excel文件的导入和导出功能。这个过程涉及到引入NPOI库、读取和解析Excel文件、将数据绑定到WPF控件上、使用NPOI导出数据到Excel文件等步骤。 ### 回答2： WPF是一种用于构建Windows应用程序的开发框架，而NPOI是一个支持读取和写入Microsoft Office格式文件的库。使用NPOI库可以在WPF应用程序中实现Excel文件的导入和导出功能。 首先需要在WPF项目中引用NPOI库，可以通过NuGet包管理器或手动引用DLL文件的方式进行添加。 要导入Excel文件，我们可以使用NPOI库提供的类来读取和解析文件。首先需要创建一个ExcelWorkbook对象，然后通过获取工作表和行、单元格的方式来获取数据。可以使用循环遍历的方法将数据导入到WPF应用程序中的数据结构中，如数据表或集合。 要导出Excel文件，我们可以使用NPOI库提供的类来创建和写入Excel文件。首先需要创建一个ExcelWorkbook对象，然后创建工作表和行对象，并将数据写入到单元格中。最后，可以使用流将Excel文件保存到指定的位置。 需要注意的是，导入和导出Excel文件时需要处理一些异常情况，如文件格式错误、IO异常等，可以使用try-catch语句来捕获并处理这些异常。 总结来说，使用NPOI库可以方便地在WPF应用程序中实现Excel文件的导入和导出功能。通过引用NPOI库，并使用它提供的类和方法，我们可以读取和解析Excel文件的数据，以及创建和写入Excel文件。这使得我们可以更加灵活和高效地处理Excel文件，满足特定的需求。 ### 回答3： WPF是一种使用XAML语言和.NET框架开发桌面应用程序的技术。NPOI是一个用于操作Microsoft Office格式文件的开源库，可以在WPF应用程序中使用NPOI来实现Excel文件的导入和导出。 在使用NPOI导入Excel文件时，首先需要引入NPOI的相关命名空间，然后通过创建一个Workbook对象来加载Excel文件。可以使用Workbook的GetSheetAt方法获取具体的工作表，并通过遍历行和列的方式获取单元格的数据。再通过将数据存储到一个集合或数据表中，便可以在WPF应用程序中进行进一步的处理和展示。 在使用NPOI导出Excel文件时，首先需要创建一个Workbook对象，并在其中创建一个工作表。然后通过遍历数据集合或数据表，使用NPOI提供的方法在工作表中添加行和列，并设置相应的单元格数值。最后，使用Workbook的Write方法将数据写入到Excel文件中，并通过保存文件的方式实现导出功能。 此外，还可以根据需求设置单元格的样式、字体、颜色等属性，以及合并单元格、设置边框等操作。通过熟悉NPOI库的API文档，可以灵活地操作Excel文件，并在WPF应用程序中实现导入和导出Excel的功能。 总之，通过使用NPOI库，可以在WPF应用程序中方便地实现Excel文件的导入和导出功能，提高了应用程序的灵活性和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值