C#用NPOI导入和导出Excel文件(.xls和.xlsx格式)

最新推荐文章于 2024-05-31 19:13:59 发布
最新推荐文章于 2024-05-31 19:13:59 发布
阅读量3.6k 收藏 8
点赞数 1
分类专栏： C#
原文链接：https://blog.csdn.net/xggbest/article/details/104217491
版权

方法 一 （MES 用的方法一）

public static class ExcelHelper
    {
        public static void ExportToExcel(DataTable dt)
        {
            ExportToExcelData(dt);
        }　　　　
        public static DataTable ToDataTable(this DataGridView myDGV)
        {
            DataTable dt = new DataTable();
            for (int i = 0; i < myDGV.ColumnCount; i++)
            {
                dt.Columns.Add(myDGV.Columns[i].HeaderText);
            }
            //写入数值
            for (int r = 0; r < myDGV.Rows.Count; r++)
            {
                List<object> values = new List<object>();
                for (int i = 0; i < myDGV.ColumnCount; i++)
                {
                    values.Add(myDGV.Rows[r].Cells[i].Value);
                }
                dt.Rows.Add(values .ToArray());
            }
            return dt;
        }
        #region 导出
        /// <summary>
        /// 数据导出
        /// </summary>
        /// <param name="data"></param>
        /// <param name="sheetName"></param>
        public static void ExportToExcelData(this DataTable data)
        {
            ExportToExcel(data, "Sheet1");
        }
        /// <summary>
        /// 数据导出
        /// </summary>
        /// <param name="data"></param>
        /// <param name="sheetName"></param>
        public static void ExportToExcel(this DataTable data, string sheetName)
        {
            SaveFileDialog fileDialog = new SaveFileDialog();
            //fileDialog.Filter = "Excel(97-2003)|*.xls|Excel(2007-2013)|*.xlsx";
            fileDialog.Filter = "Excel|*.xls|Excel|*.xlsx";
            if (fileDialog.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
            {
                return;
            }
            IWorkbook workbook = new XSSFWorkbook();
            ISheet sheet = workbook.CreateSheet(sheetName);
            IRow rowHead = sheet.CreateRow(0);

            //填写表头
            for (int i = 0; i < data.Columns.Count; i++)
            {
                rowHead.CreateCell(i, CellType.String).SetCellValue(data.Columns[i].ColumnName.ToString());
            }
            //填写内容
            for (int i = 0; i < data.Rows.Count; i++)
            {
                IRow row = sheet.CreateRow(i + 1);
                for (int j = 0; j < data.Columns.Count; j++)
                {
                    row.CreateCell(j, CellType.String).SetCellValue(data.Rows[i][j].ToString());
                }
            }

            for (int i = 0; i < data.Columns.Count; i++)
            {
                sheet.AutoSizeColumn(i);
            }

            using (FileStream stream = File.OpenWrite(fileDialog.FileName))
            {
                workbook.Write(stream);
                stream.Close();
            }
            MessageBox.Show("导出数据成功!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
            GC.Collect();
        }
        #endregion

        #region 导入
        /// <summary>
        /// 导入的文件名
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static DataSet ExcelToDataSet(string fileName)
        {
            return ExcelToDataSet(fileName, true);
        }
        /// <summary>
        /// 返回dataset
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="firstRowAsHeader"></param>
        /// <returns></returns>
        public static DataSet ExcelToDataSet(string fileName, bool firstRowAsHeader)
        {
            int sheetCount = 0;
            return ExcelToDataSet(fileName, firstRowAsHeader, out sheetCount);
        }
        /// <summary>
        /// 返回dataset
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="firstRowAsHeader">文件头</param>
        /// <param name="sheetCount">内容</param>
        /// <returns></returns>
        public static DataSet ExcelToDataSet(string fileName, bool firstRowAsHeader, out int sheetCount)
        {
            using (DataSet ds = new DataSet())
            {
                using (FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
                {
                    IWorkbook workbook = WorkbookFactory.Create(fileStream);
                    IFormulaEvaluator evaluator = WorkbookFactory.CreateFormulaEvaluator(workbook);

                    sheetCount = workbook.NumberOfSheets;

                    for (int i = 0; i < sheetCount; ++i)
                    {
                        ISheet sheet = workbook.GetSheetAt(i);
                        DataTable dt = ExcelToDataTable(sheet, evaluator, firstRowAsHeader);
                        ds.Tables.Add(dt);
                    }
                    return ds;
                }
            }
        }
        /// <summary>
        /// 返回DataTable
        /// </summary>
        /// <param name="sheet"></param>
        /// <param name="evaluator"></param>
        /// <param name="firstRowAsHeader"></param>
        /// <returns></returns>
        private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator, bool firstRowAsHeader)
        {
            if (firstRowAsHeader)
            {
                return ExcelToDataTableFirstRowAsHeader(sheet, evaluator);
            }
            else
            {
                return ExcelToDataTable(sheet, evaluator);
            }
        }
        private static DataTable ExcelToDataTableFirstRowAsHeader(ISheet sheet, IFormulaEvaluator evaluator)
        {
            try
            {
                using (DataTable dt = new DataTable())
                {
                    IRow firstRow = sheet.GetRow(0);
                    int cellCount = GetCellCount(sheet);

                    for (int i = 0; i < cellCount; i++)
                    {
                        if (firstRow.GetCell(i) != null)
                        {
                            dt.Columns.Add(firstRow.GetCell(i).StringCellValue ?? string.Format("F{0}", i + 1), typeof(string));
                        }
                        else
                        {
                            dt.Columns.Add(string.Format("F{0}", i + 1), typeof(string));
                        }
                    }

                    for (int i = 1; i <= sheet.LastRowNum; i++)
                    {
                        IRow row = sheet.GetRow(i);
                        DataRow dr = dt.NewRow();
                        FillDataRowByRow(row, evaluator, ref dr);
                        dt.Rows.Add(dr);
                    }

                    dt.TableName = sheet.SheetName;
                    return dt;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return null;
            }
        }
        private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator)
        {
            using (DataTable dt = new DataTable())
            {
                if (sheet.LastRowNum != 0)
                {
                    int cellCount = GetCellCount(sheet);

                    for (int i = 0; i < cellCount; i++)
                    {
                        dt.Columns.Add(string.Format("F{0}", i), typeof(string));
                    }

                    for (int i = 0; i < sheet.FirstRowNum; ++i)
                    {
                        DataRow dr = dt.NewRow();
                        dt.Rows.Add(dr);
                    }

                    for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; i++)
                    {
                        IRow row = sheet.GetRow(i);
                        DataRow dr = dt.NewRow();
                        FillDataRowByRow(row, evaluator, ref dr);
                        dt.Rows.Add(dr);
                    }
                }

                dt.TableName = sheet.SheetName;
                return dt;
            }
        }
        /// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="row"></param>
        /// <param name="evaluator"></param>
        /// <param name="dr"></param>
        private static void FillDataRowByRow(IRow row, IFormulaEvaluator evaluator, ref DataRow dr)
        {
            if (row != null)
            {
                for (int j = 0; j < dr.Table.Columns.Count; j++)
                {
                    ICell cell = row.GetCell(j);

                    if (cell != null)
                    {
                        switch (cell.CellType)
                        {
                            case CellType.Blank:
                                {
                                    dr[j] = DBNull.Value;
                                    break;
                                }
                            case CellType.Boolean:
                                {
                                    dr[j] = cell.BooleanCellValue;
                                    break;
                                }
                            case CellType.Numeric:
                                {
                                    if (DateUtil.IsCellDateFormatted(cell))
                                    {
                                        dr[j] = cell.DateCellValue;
                                    }
                                    else
                                    {
                                        dr[j] = cell.NumericCellValue;
                                    }
                                    break;
                                }
                            case CellType.String:
                                {
                                    dr[j] = cell.StringCellValue;
                                    break;
                                }
                            case CellType.Error:
                                {
                                    dr[j] = cell.ErrorCellValue;
                                    break;
                                }
                            case CellType.Formula:
                                {
                                    cell = evaluator.EvaluateInCell(cell) as HSSFCell;
                                    dr[j] = cell.ToString();
                                    break;
                                }
                            default:
                                throw new NotSupportedException(string.Format("Unsupported format type:{0}", cell.CellType));
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 获取单元格
        /// </summary>
        /// <param name="sheet"></param>
        /// <returns></returns>
        private static int GetCellCount(ISheet sheet)
        {
            int firstRowNum = sheet.FirstRowNum;

            int cellCount = 0;

            for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; ++i)
            {
                IRow row = sheet.GetRow(i);

                if (row != null && row.LastCellNum > cellCount)
                {
                    cellCount = row.LastCellNum;
                }
            }
            return cellCount;
        }


        #endregion

    }

调用

//导出
if (UserinfDg.Rows.Count > 0)
  {
       ExcelHelper.ExportToExcel(UserinfDg.ToDataTable());
  }

//导入EXCEL档 导入用此方法
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.InitialDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Desktop);
openFileDialog.RestoreDirectory = true;
openFileDialog.Filter = "Excel Office97-2003(*.xls)|.xls|Excel Office2007及以上(*.xlsx)|*.xlsx";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
    string filePath = openFileDialog.FileName;
    UserinfDg.DataSource = ExcelHelper.ExcelToDataSet(filePath).Tables[0];
}

*************************************************************************************************************

方法 二

1、安装NPOI

右键项目 → “管理NuGet程序包” → 搜索NPOI → 安装

2、创建类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using NPOI.SS.UserModel;
using NPOI.HSSF.UserModel;//导出xls格式用HSSF
using NPOI.XSSF.UserModel;//导出xlsx格式用XSSF
using System.IO;
using System.Runtime.InteropServices;
using System.Diagnostics;
using NPOI.SS.Util;


namespace ExportToExcel
{
    public class ExportDgvToExcel
    {
        #region  NPOI DataGridView 导出 EXCEL
        /// <summary>
        ///  NPOI DataGridView 导出 EXCEL
        ///  03版Excel-xls最大行数是65536行,最大列数是256列
        ///  07版Excel-xlsx最大行数是1048576行,最大列数是16384列
        /// </summary>
        /// <param name="fileName">默认保存文件名</param>
        /// <param name="dgv">DataGridView</param>
        /// <param name="fontname">字体名称</param>
        /// <param name="fontsize">字体大小</param> 

        public void ExportExcel(string fileName, DataGridView dgv, string fontname, short fontsize)
        {
            IWorkbook workbook;
            ISheet sheet;
            Stopwatch sw = null;            

            //判断datagridview中内容是否为空
            if (dgv.Rows.Count == 0)
            {
                MessageBox.Show("DataGridView中内容为空,请先导入数据!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            //保存文件
            string saveFileName = "";
            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.DefaultExt = "xls";
            saveFileDialog.Filter = "Excel文件(*.xls)|*.xls|Excel文件(*.xlsx)|*.xlsx";
            saveFileDialog.RestoreDirectory = true;
            saveFileDialog.Title = "Excel文件保存路径";
            saveFileDialog.FileName = fileName;
            MemoryStream ms = new MemoryStream(); //MemoryStream
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {            
                //**程序开始计时**//
                sw = new Stopwatch();
                sw.Start();

                saveFileName = saveFileDialog.FileName;

                //检测文件是否被占用
                if (!CheckFiles(saveFileName))
                {
                    MessageBox.Show("文件被占用,请关闭文件" + saveFileName);
                    workbook = null;
                    ms.Close();
                    ms.Dispose();
                    return;
                }               
            }
            else
            {
                workbook = null;
                ms.Close();
                ms.Dispose();
            }            

            //*** 根据扩展名xls和xlsx来创建对象
            string fileExt = Path.GetExtension(saveFileName).ToLower();
            if (fileExt == ".xlsx")
            {
                workbook = new XSSFWorkbook();           
            }
            else if (fileExt == ".xls")
            {
                workbook = new HSSFWorkbook();        
            }
            else
            {
                workbook = null;
            }
            //***

            //创建Sheet
            if (workbook != null)
            {
                sheet = workbook.CreateSheet("Sheet1");//Sheet的名称  
            }
            else
            {
                return;
            }                                                  

            //设置单元格样式
            ICellStyle cellStyle = workbook.CreateCellStyle();
            //水平居中对齐和垂直居中对齐
            cellStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
            cellStyle.VerticalAlignment = NPOI.SS.UserModel.VerticalAlignment.Center;
            //设置字体
            IFont font = workbook.CreateFont();
            font.FontName = fontname;//字体名称
            font.FontHeightInPoints = fontsize;//字号
            font.Color = NPOI.HSSF.Util.HSSFColor.Black.Index;//字体颜色
            cellStyle.SetFont(font);

            //添加列名
            IRow headRow = sheet.CreateRow(0);
            for (int i = 0; i < dgv.Columns.Count; i++)
            {
                //隐藏行列不导出
                if (dgv.Columns[i].Visible == true)
                {
                    headRow.CreateCell(i).SetCellValue(dgv.Columns[i].HeaderText);
                    headRow.GetCell(i).CellStyle = cellStyle;
                }                
            }           

            //根据类型写入内容
            for (int rowNum = 0; rowNum < dgv.Rows.Count; rowNum++)
            {
                ///跳过第一行,第一行为列名
                IRow dataRow = sheet.CreateRow(rowNum + 1);
                for (int columnNum = 0; columnNum < dgv.Columns.Count; columnNum++)
                {
                    int columnWidth = sheet.GetColumnWidth(columnNum) / 256; //列宽

                    //隐藏行列不导出
                    if (dgv.Rows[rowNum].Visible == true && dgv.Columns[columnNum].Visible == true)
                    {
                        //防止行列超出Excel限制
                        if (fileExt == ".xls")
                        {
                            //03版Excel最大行数是65536行,最大列数是256列
                            if (rowNum > 65536)
                            {
                                MessageBox.Show("行数超过Excel限制!");
                                return;
                            }
                            if (columnNum > 256)
                            {
                                MessageBox.Show("列数超过Excel限制!");
                                return;
                            }
                        }
                        else if (fileExt == ".xlsx")
                        {
                            //07版Excel最大行数是1048576行,最大列数是16384列
                            if (rowNum > 1048576)
                            {
                                MessageBox.Show("行数超过Excel限制!");
                                return;
                            }
                            if (columnNum > 16384)
                            {
                                MessageBox.Show("列数超过Excel限制!");
                                return;
                            }
                        }

                        ICell cell = dataRow.CreateCell(columnNum);
                        if (dgv.Rows[rowNum].Cells[columnNum].Value == null)
                        {
                            cell.SetCellType(CellType.Blank);
                        }
                        else
                        {
                            if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.Int32"))
                            {
                                cell.SetCellValue(Convert.ToInt32(dgv.Rows[rowNum].Cells[columnNum].Value));
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.String"))
                            {
                                cell.SetCellValue(dgv.Rows[rowNum].Cells[columnNum].Value.ToString());
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.Single"))
                            {
                                cell.SetCellValue(Convert.ToSingle(dgv.Rows[rowNum].Cells[columnNum].Value));
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.Double"))
                            {
                                cell.SetCellValue(Convert.ToDouble(dgv.Rows[rowNum].Cells[columnNum].Value));
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.Decimal"))
                            {
                                cell.SetCellValue(Convert.ToDouble(dgv.Rows[rowNum].Cells[columnNum].Value));
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.DateTime"))
                            {
                                cell.SetCellValue(Convert.ToDateTime(dgv.Rows[rowNum].Cells[columnNum].Value).ToString("yyyy-MM-dd"));
                            }
                            else if (dgv.Rows[rowNum].Cells[columnNum].ValueType.FullName.Contains("System.DBNull"))
                            {
                                cell.SetCellValue("");
                            }    
                        }

                        //设置列宽
                        IRow currentRow;
                        if (sheet.GetRow(rowNum) == null)
                        {
                            currentRow = sheet.CreateRow(rowNum);
                        }
                        else
                        {
                            currentRow = sheet.GetRow(rowNum);
                        }

                        if (currentRow.GetCell(columnNum) != null)
                        {
                            ICell currentCell = currentRow.GetCell(columnNum);
                            int length = Encoding.Default.GetBytes(currentCell.ToString()).Length;

                            if (columnWidth < length)
                            {
                                columnWidth = length + 10; //设置列宽数值
                            }
                        }
                        sheet.SetColumnWidth(columnNum, columnWidth * 256);

                        //单元格样式
                        dataRow.GetCell(columnNum).CellStyle = cellStyle;
                    }                    
                }
            }

            //保存为Excel文件                  
            workbook.Write(ms);
            FileStream file = new FileStream(saveFileName, FileMode.Create);
            workbook.Write(file);
            file.Close();
            workbook = null;
            ms.Close();
            ms.Dispose();

            //**程序结束计时**//
            sw.Stop();
            double totalTime = sw.ElapsedMilliseconds / 1000.0;

            MessageBox.Show(fileName + " 导出成功\n耗时" + totalTime + "s", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        #endregion


        #region 检测文件是否被占用 
        /// <summary>
        /// 判定文件是否打开
        /// </summary>   
        [DllImport("kernel32.dll")]
        public static extern IntPtr _lopen(string lpPathName, int iReadWrite);
        [DllImport("kernel32.dll")]
        public static extern bool CloseHandle(IntPtr hObject);
        public const int OF_READWRITE = 2;
        public const int OF_SHARE_DENY_NONE = 0x40;
        public readonly IntPtr HFILE_ERROR = new IntPtr(-1);

        /// <summary>
        /// 检测文件被占用 
        /// </summary>
        /// <param name="FileNames">要检测的文件路径</param>
        /// <returns></returns>
        public bool CheckFiles(string FileNames)
        {
            if (!File.Exists(FileNames))
            {
                //文件不存在
                return true;
            }
            IntPtr vHandle = _lopen(FileNames, OF_READWRITE | OF_SHARE_DENY_NONE);
            if (vHandle == HFILE_ERROR)
            {
                //文件被占用
                return false;
            }
            //文件没被占用
            CloseHandle(vHandle);
            return true;
        }
        #endregion                            
    }
}

3.调用

private void btnExport_Click_1(object sender, EventArgs e)
{
	ExportDgvToExcel export = new ExportDgvToExcel();
	export.ExportExcel("", dgv, "宋体", 11);//默认文件名,DataGridView控件的名称,字体,字号 
}

s01896
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#使用NPOI实现导入导出Excel数据
CoffeMilk的博客
09-18 1万+
一、NPOI简介 1.1、NPOI是什么 　　NPOI是POI的.NET版本,POI是一套用Java写成的库，我们在开发中经常用到导入导出表格、文档的情况，NPOI能够帮助我们在没有安装微软Office的情况下读写Office文件，如xls, doc, ppt等。NPOI采用的是Apache 2.0许可证（poi也是采用这个许可证），这意味着它可以被用于任何商业或非商业项目，我们不用担心因为使用它而必须开放你自己的源代码，所以它对于很多从事业务系统开发的公司来说绝对是很不错的选择。 1.2、NPOI简
C# Excel导入导出，基于NOPI（兼容xls和xlsx）
12-30
在处理Excel文件时，务必注意文件格式（.xls或.xlsx）与使用的Workbook类的匹配，以及正确处理可能出现的异常和错误，确保程序的健壮性。在实际项目中，根据`Exceltest`这样的示例文件进行实践，有助于更好地理解和...
NPOI 导出xlsx 出现的问题解决方案
04-09 2411
NPOI 导出xlsx 出现的问题解决方案出现的问题 出现的问题 在使用NPOI 导出 Excel为 xlsx 格式的文件时候。使用 stream 流来输出，会出现 “Can not access a closed Stream” 的报错。 这是因为：XSSF类在 workbook.write(ms) 后，就会自动关闭这个 MemoryStream. 所以导致了这个错误 解决方案：不导出xlsx文件，导出xls就好 因为 2000版本的 Excel文件最多支持的行数有限，而且现在大多都是 2007版本，所以
C#基于Npoi通过特性的方式导出简单数据到Excel或基于特性以及基于Excel模板导出数据到Excel以及从Excel中把数据导入到对象中
weixin_43872830的博客
05-20 3452
基于Npoi/Excel模板以及结合特性完成数据导出到Excel中，这里你可以以最简单的方式实现数据导出到Excel或基于Excel模板导出
C#NPOI应用（导入导出Excel）
最新发布
lingxiao16888的博客
05-31 779
NPOI，顾名思义，就是POI的.NET版本。用于读取和写入Microsoft Office二进制和OOXML文件格式。NPOI，顾名思义，就是POI的.NET版本。那POI又是什么呢？POI是一套用Java写成的库，能够帮助开发者在没有安装微软Office的情况下读写Office 97-2003的文件，支持的文件格式包括xls, doc, ppt等。在本文发布时，POI的最新版本是3.5 beta 6。NPOI 1.x是基于POI 3.x版本开发的，与poi 3.2对应的版本是NPOI 1.2，
C#.net导出标准的Excel（npoi）
高彬的专栏
11-07 5756
不管用哪一种语言开发应用程序，导出功能是最常见的，一般导出文件格式最常见的有PDF 、Excel、CSV、Word、TXT等，今天我们在此介绍一下Excel的导出方法。 微软提供了导出Excel的多种办法，但是今天我们在这里只介绍一种第三方的导出方法，因为它简单，更多符合我们的编程习惯（个人观点），下面开始： 一、下载，官网地址：https://npoi.codeplex.c
C# 导出 Excel 的各种方法总结
热门推荐
藿香正气片博客
05-28 1万+
第一种：使用 Microsoft.Office.Interop.Excel.dll 首先需要安装 office 的 excel，然后再找到Microsoft.Office.Interop.Excel.dll 组件，添加到引用。 public void ExportExcel(DataTable dt) { if (dt != null) ...
基于NPOI导入导出Excel文件.rar
03-08
3. **NPOI库**：NPOI提供了一个易于使用的接口，允许开发者创建、修改和读取Excel文件（.xlsx和.xls格式）。它支持多种操作，如创建工作簿、添加工作表、写入单元格数据、设置样式等。在这个案例中，NPOI用于从SQL...
C#代码NPOI实现的Excel导入导出.rar
06-27
总之，这个压缩包提供的资源可以帮助C#开发者快速掌握如何使用NPOI进行Excel文件的导入和导出。通过学习和实践，开发者可以构建高效的数据处理系统，无论是在后台批量处理数据，还是在前端提供用户友好的Excel交互...
C# 导入EXCEL文件和导出EXCEL文件
12-14
NPOI是一个开源的.NET库，专门用于读写Microsoft Office文件格式，包括Excel（.xls和.xlsx）。它提供了一套易于使用的API，使得开发者可以在不依赖Microsoft Office的情况下处理Excel数据。 **导入Excel文件** 1. *...
C#使用NPOI导入Excel的方法详解
12-31
本文实例讲述了C#使用NPOI导入Excel的方法。分享给大家供大家参考，具体如下： NPOI是由国人开发的一个进行excel操作的第三方库。百度百科介绍如下：NPOI 本文主要介绍如何使用NPOI将Excel数据读取。 首先引入程序集： using System.IO; using System.Reflection; using NPOI.HSSF.UserModel; using NPOI.SS.UserModel; using System.Web; 然后定位到文件位置： string path = ~/上传文件/custompersonsalary/ + id + /+
C#使用NPOI操作excel例子(含.xls、.xlsx)等
11-09
C#使用NPOI操作excel例子(含.xls、.xlsx)等. 使用了不同版本的dll，并且有对应的工具类。
NPOI读写EXCEL相关dll（支持xls及xlsx）
12-11
NPOI读写EXCEL相关dll（支持xls及xlsx），相关参考https://blog.csdn.net/funkstill/article/details/84958700
C# Excel格式转换，xls转换成xlsx，不依赖Excel，不依赖office
02-03
支持单元格格式，合并单元格转换，不依赖安装excel，使用开源NPOI 2.5.1版本，VS2019调试通过
NPOI.rar NPOI C# 调用导出xlsx文件
09-18
NPOI是一个强大的开源库，专门用于处理Microsoft Office文件格式，包括Excel的XLS和XLSX文件。在C#编程环境下，NPOI提供了一种高效且灵活的方式来创建、读取和修改Excel文档，无需依赖Microsoft Office。下面将详细...
C# 实现xls类型转换为xlsx类型
flysh05的专栏
02-21 2401
Office97-2003 创建的Excel文件后缀为xls, Office 2007 之后的版本创建的Excel文件后缀为 xlsx,在C#中使用EPPLUS模块读取2003版本创建的Excel存在一些问题，但是2007版本后创建的Excel不存在问题，所以需要将xls 版本转换为xlsx版本再操作，就不存在问题。例如：存在一个 Sample.xls 文件 转换代码如下：         private
c#使用NPOI进行Excel导入导出，附源码，vs2010
03-22 1117
目录 1.介绍：描述第三方类库NPOI以及Excel结构 2.Excel导入：介绍C#如何调用NPOI进行Excel导入，包含：流程图、NOPI以及C#代码 3.Excel导出：介绍C#如何调用NPOI进行Excel导出，包含：流程图、NOPI以、C#代码以及代码分析 4.源码下载：展示运行图及源码下载 1. 介绍 1.1 第三方类库：NPOI 说明：NPOI是POI...
Winform中通过NPOI导出Excel的三种方式(HSSFWorkbook，XSSFWorkbook，SXSSFWorkbook)附代码下载
BADAO_LIUMANG_QIZHI的博客
05-29 5514
场景 HSSFworkbook,XSSFworkbook,SXSSFworkbook区别 HSSFWorkbook: 是操作Excel2003以前（包括2003）的版本，扩展名是.xls；导出excel最常用的方式；但是此种方式的局限就是导出的行数至多为65535行，超出65536条后系统就会报错。 XSSFWorkbook: 是操作Excel2007后的版本，扩展名是.xlsx；为了突破HSSFWorkbook的65535行局限。其对应的是excel2007(1048576行，16384列)扩展
使用npoi读写excel(.xls,.xlsx)示例代码(不用安装office)
05-01
NPOI是一个.NET平台下的开源组件，用于读写Microsoft Office格式的文档。下面是使用NPOI读写Excel文件(.xls,.xlsx)的示例代码： 读取Excel文件： 1. 首先，需要引入NPOI的命名空间：using NPOI.HSSF.UserModel; // 导入xls格式 using NPOI.XSSF.UserModel;// 导入xlsx格式 2. 创建文件流对象，打开Excel文件：FileStream fs = new FileStream("D:\\test.xlsx", FileMode.Open, FileAccess.Read); 3. 根据文件流对象创建Excel工作簿对象：IWorkbook wb = WorkbookFactory.Create(fs); 4. 获取第一个工作表：ISheet sheet1 = wb.GetSheetAt(0); 5. 遍历工作表，获取单元格值：for (int i = sheet1.FirstRowNum + 1; i <= sheet1.LastRowNum; i++) { IRow row = sheet1.GetRow(i); if (row == null) continue; for (int j = row.FirstCellNum; j < row.LastCellNum; j++) { string cellvalue = row.GetCell(j).ToString(); Console.WriteLine(cellvalue); } } 写入Excel文件： 1. 创建Excel工作簿对象：IWorkbook wb = new XSSFWorkbook(); 2. 创建一个工作表：ISheet sheet1 = wb.CreateSheet("Sheet1"); 3. 创建一行：IRow row = sheet1.CreateRow(0); 4. 创建单元格并设置值：row.CreateCell(0).SetCellValue("姓名"); row.CreateCell(1).SetCellValue("年龄"); row.CreateCell(2).SetCellValue("籍贯"); 5. 保存Excel文件：FileStream fs = new FileStream("D:\\test.xlsx", FileMode.Create, FileAccess.Write); wb.Write(fs); 通过以上示例代码，可以轻松地使用NPOI读写Excel文件，而且不需要安装Office。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值