本文的代码是博主自己写的一个Demo，用来记录EPPlues的{%label 简单使用 blue %}

读写高级版本的xlsx不要用NPOI, 建议使用EPPLUS

如果是网站生成数据格式，供用户下载，NPOI没有问题，如果是反复读写的场景，甚至还有用户修改这个excle文件的话，比如电脑端NPOI对这个文件读写，用户在手机端修改同一个文件，建议用EPPLUS

{%label 代码中所有的库文件在NuGet中都可以下载，这里不做演示 %}，下面是代码：

using OfficeOpenXml;
using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 自动导出报表
{
    public partial class Main : Form
    {
        //存放报表生成的路径：bin/Debug/Files
        private string path = Environment.CurrentDirectory + "\\Files\\";
        //日志
        private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();

        public Main()
        {
            InitializeComponent();
        }

        private void Main_Load(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// 开始计时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            //开始计时，每隔 86400000 毫秒（24小时）执行一次
            this.AutomaticExport.Start();
            //执行方法
            Export();
        }

        /// <summary>
        /// 停止计时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            //停止计时器
            this.AutomaticExport.Stop();
        }

        /// <summary>
        /// 查看按钮 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {
            //获取当前月
            int Month = DateTime.Now.Month;
            //获取昨天对应的年份
            int Year = DateTime.Now.AddDays(-1).Year;
            string yearPath = path + Year + "\\";
            //获取本地存放的文件
            string filePath = yearPath + $"{Month}月报表.xlsx";

            if (File.Exists(filePath))
            {
                try
                {
                    System.Diagnostics.Process.Start(filePath);
                    Logger.Trace($"查看报表：{Month}月，成功！");
                }
                catch (Exception ex)
                {
                    Logger.Warn(ex.Message);
                    MessageBox.Show(ex.ToString());
                }
            }
            else
            {
                Logger.Trace($"查看报表：暂无{Month}月的报表！");
                MessageBox.Show($"暂无{Month}月的报表！");
            }
        }

        private void AutomaticExport_Tick(object sender, EventArgs e)
        {
            //计时器调用方法
            Export();
        }

        /// <summary>
        /// 导出报表
        /// </summary>
        public void Export() 
        {
            //获取昨天的日期，格式为：2021-12-12
            string YesterDay = DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd");
            //获取昨天对应的年份（用于创建存放报表的文件夹）
            int Year = DateTime.Now.AddDays(-1).Year;
            //获取昨天对应的月份（用于创建每个月对应的报表）
            int Month = DateTime.Now.AddDays(-1).Month;
            //获取昨天的初始时间（用于SQL语句中当筛选条件）2021-12-12 00:00:00.000
            string YesterDayBegin = YesterDay + " 00:00:00.000";
            //获取昨天的结束时间（用于SQL语句中当筛选条件）2021-12-12 24:00:00.000
            string YesterDayEnd = YesterDay + " 24:00:00.000";
            //表示个人权限，非商用（不加上这一句会提示没有权限）
            ExcelPackage.LicenseContext = LicenseContext.NonCommercial;


            String sql = "select top 140000* from FlowRecords";
            //参数化传值防止SQL注入（需要传递参数时使用）
            //String sql = "select top 14000* from FlowRecords where Id = @Id";
            /*SqlParameter[] pms = new SqlParameter[]
            {
                //@Id:对应上面sql语句的@Id，SqlDbType.Int设置这个参数的类型，4：设置参数的长度，Value：设置参数的值
                new SqlParameter("@Id",SqlDbType.Int,4){ Value = 111},
            };*/
            DataTable db = SqlHelper.ExecuteDataTable(sql);
            Logger.Trace($"共查询到{db.Rows.Count}条数据。");


            string yearPath = path + Year + "\\";
            //创建一个文件夹用来存放一年的报表
            if (!Directory.Exists(path + Year))
            {
                Directory.CreateDirectory(path + Year);
            }
            string excelFilePath = yearPath + $@"{Month}月报表.xlsx";

            if (!System.IO.File.Exists(excelFilePath))//不存在则创建
            {
                FileInfo newFile = new FileInfo(excelFilePath);
                using (ExcelPackage package = new ExcelPackage(newFile))
                {
                    //添加工作表
                    ExcelWorksheet worksheet = package.Workbook.Worksheets.Add($"{Month}月");
                    //添加标题
                    worksheet.Cells[1, 1].Value = "标题1";
                    worksheet.Cells[1, 2].Value = "标题2";
                    worksheet.Cells[1, 3].Value = "标题3";
                    worksheet.Cells[1, 4].Value = "标题4";
                    worksheet.Cells[1, 5].Value = "标题5";
                    worksheet.Cells[1, 6].Value = "标题6";
                    worksheet.Cells[1, 7].Value = "标题7";
                    worksheet.Cells[1, 8].Value = "标题8";
                    worksheet.Cells[1, 9].Value = "标题9";
                    worksheet.Cells[1, 10].Value = "标题10";
                    worksheet.Cells[1, 11].Value = "标题11";
                    worksheet.Cells[1, 12].Value = "标题12";
                    worksheet.Cells[1, 13].Value = "标题13";
                    worksheet.Cells[1, 14].Value = "标题14";
                    package.Save();
                    Logger.Trace($@"【{Month}月报表.xlsx】创建成功！");
                }//using end

            }//if end

            if (System.IO.File.Exists(excelFilePath)) //如果文件存在则往下执行
            {
                FileInfo newFile = new FileInfo(excelFilePath);
                using (ExcelPackage package = new ExcelPackage(newFile))
                {
                    //获取工作表
                    ExcelWorksheet worksheet = package.Workbook.Worksheets[0];
                    //拿到最后一行，这里其实获取的是总行数，追加数据需要+1
                    int lastRow = worksheet.Dimension.End.Row;
                    for (int i = 1; i < db.Rows.Count + 1; i++)
                    {
                        worksheet.Cells[lastRow + i, 1].Value = db.Rows[i - 1]["Id"];
                        worksheet.Cells[lastRow + i, 2].Value = db.Rows[i - 1]["WorkOrderId"];
                        worksheet.Cells[lastRow + i, 3].Value = db.Rows[i - 1]["CreatedAt"];
                        worksheet.Cells[lastRow + i, 4].Value = db.Rows[i - 1]["UpdatedAt"];
                        worksheet.Cells[lastRow + i, 5].Value = db.Rows[i - 1]["MaterialId"];
                        worksheet.Cells[lastRow + i, 6].Value = db.Rows[i - 1]["Batch"];
                        worksheet.Cells[lastRow + i, 7].Value = db.Rows[i - 1]["QCStatus"];
                        worksheet.Cells[lastRow + i, 8].Value = db.Rows[i - 1]["Account"];
                        worksheet.Cells[lastRow + i, 9].Value = db.Rows[i - 1]["SO"];
                        worksheet.Cells[lastRow + i, 10].Value = db.Rows[i - 1]["SOLine"];
                        worksheet.Cells[lastRow + i, 11].Value = db.Rows[i - 1]["xNumber"];
                        worksheet.Cells[lastRow + i, 12].Value = db.Rows[i - 1]["Unit"];
                        worksheet.Cells[lastRow + i, 13].Value = db.Rows[i - 1]["RelatedParty"];
                        worksheet.Cells[lastRow + i, 14].Value = db.Rows[i - 1]["BusinessTypeId"];
                    }//for end

                    package.Save();
                    Logger.Trace($@"【{Month}月报表.xlsx】数据添加成功！");

                }//using end

            }//if end

        }//Export end

    }
}

SqlHelper 代码:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Collections;
using System.Data.SqlClient;


/// <summary> 
/// 数据库的通用访问代码
/// 此类为抽象类，不允许实例化，在应用时直接调用即可
/// </summary> 
public abstract class SqlHelper
{
    // 获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改 
    public static readonly string ConnectionStringLocalTransaction = "数据库连接字段";

    // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。 
    private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

    public static SqlTransaction BeginTransaction(string con)
    {
        SqlConnection connection = new SqlConnection(con);
        connection.Open();
        SqlTransaction tran = connection.BeginTransaction();
        return tran;
    }

    /// <summary> 
    /// 执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
    /// 使用参数数组形式提供参数列表 
    /// </summary> 
    /// <remarks> 
    /// 使用示例：
    /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="connectionString"> 一个有效的数据库连接字符串 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个数值表示此SqlCommand命令执行后影响的行数 </returns> 
    public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {

        SqlCommand cmd = new SqlCommand();

        using (SqlConnection conn = new SqlConnection(connectionString))
        {
            int val = 0;
            try
            {
                // 通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中 
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                val = cmd.ExecuteNonQuery();
                // 清空SqlCommand中的参数列表 
                cmd.Parameters.Clear();
            }
            catch
            {
                val = 0;
            }
            finally
            {
                conn.Close();
                conn.Dispose();
            }
            return val;
        }
    }

    /// <summary> 
    /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接 
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="conn"> 一个现有的数据库连接 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个数值表示此SqlCommand命令执行后影响的行数 </returns> 
    public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        int val = 0;
        try
        {
            SqlCommand cmd = new SqlCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();

        }
        catch
        {
            val = -1;
        }
        finally
        {
            connection.Close();
            connection.Dispose();
        }
        return val;
    }

    /// <summary> 
    /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理 
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="trans"> 一个存在的 sql 事物处理 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个数值表示此SqlCommand命令执行后影响的行数 </returns> 
    public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        int val = 0;

        SqlCommand cmd = new SqlCommand();
        PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
        val = cmd.ExecuteNonQuery();
        cmd.Parameters.Clear();

        return val;
    }

    /// <summary> 
    /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="connectionString"> 一个有效的数据库连接字符串 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个包含结果的SqlDataReader </returns> 
    public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        SqlCommand cmd = new SqlCommand();
        SqlConnection conn = new SqlConnection(connectionString);
        SqlDataReader rdr = null;
        // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
        // CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
        // 关闭数据库连接，并通过throw再次引发捕捉到的异常。 
        try
        {
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
            rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
        }
        catch
        {
            throw;
        }
        finally
        {
            conn.Close();
            conn.Dispose();
        }
        return rdr;
    }
    /// <summary> 
    /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// DateSet ds = ExecuteDataSet(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="connectionString"> 一个有效的数据库连接字符串 </param> 
    /// <param name="cmdType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="cmdText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个包含结果的DataSet </returns> 
    public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        SqlCommand cmd = new SqlCommand();
        SqlConnection conn = new SqlConnection(connectionString);
        try
        {
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            adapter.Fill(ds);
            return ds;
        }
        catch
        {
            throw;
        }
        finally
        {
            conn.Close();
            conn.Dispose();
        }

    }
    /// <summary> 
    /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。 
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="connectionString"> 一个有效的数据库连接字符串 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型 </returns> 
    public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        SqlCommand cmd = new SqlCommand();

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }
    }

    /// <summary> 
    /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
    /// 使用参数数组提供参数
    /// </summary> 
    /// <remarks> 
    /// 使用示例： 
    /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
    /// </remarks> 
    /// <param name="conn"> 一个已经存在的数据库连接 </param> 
    /// <param name="commandType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="commandText"> 存储过程的名字或者 T-SQL 语句 </param> 
    /// <param name="commandParameters"> 以数组形式提供SqlCommand命令中用到的参数列表 </param> 
    /// <returns> 返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型 </returns> 
    public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {

        SqlCommand cmd = new SqlCommand();

        PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
        object val = cmd.ExecuteScalar();
        cmd.Parameters.Clear();
        return val;
    }

    /// <summary> 
    /// 缓存参数数组
    /// </summary> 
    /// <param name="cacheKey"> 参数缓存的键值 </param> 
    /// <param name="cmdParms"> 被缓存的参数列表 </param> 
    public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
    {
        parmCache[cacheKey] = commandParameters;
    }

    /// <summary> 
    /// 获取被缓存的参数
    /// </summary> 
    /// <param name="cacheKey"> 用于查找参数的KEY值 </param> 
    /// <returns> 返回缓存的参数数组 </returns> 
    public static SqlParameter[] GetCachedParameters(string cacheKey)
    {
        SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

        if (cachedParms == null)
            return null;

        // 新建一个参数的克隆列表 
        SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

        // 通过循环为克隆参数列表赋值 
        for (int i = 0, j = cachedParms.Length; i < j; i++)
            // 使用clone方法复制参数列表中的参数 
            clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

        return clonedParms;
    }

    /// <summary> 
    /// 为执行命令准备参数
    /// </summary> 
    /// <param name="cmd"> SqlCommand 命令 </param> 
    /// <param name="conn"> 已经存在的数据库连接 </param> 
    /// <param name="trans"> 数据库事物处理 </param> 
    /// <param name="cmdType"> SqlCommand命令类型 (存储过程， T-SQL语句， 等等。) </param> 
    /// <param name="cmdText"> Command text，T-SQL语句 例如 Select * from Products </param> 
    /// <param name="cmdParms"> 返回带参数的命令 </param> 
    private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
    {


        // 判断数据库连接状态 
        if (conn.State != ConnectionState.Open)
            conn.Open();

        cmd.Connection = conn;
        cmd.CommandText = cmdText;

        // 判断是否需要事物处理 
        if (trans != null)
            cmd.Transaction = trans;

        cmd.CommandType = cmdType;

        if (cmdParms != null)
        {
            // foreach (SqlParameter parm in cmdParms) 
            cmd.Parameters.AddRange(cmdParms);
        }


    }

    //1.执行增、删、改的方法：ExecuteNonQuery
    public static int ExecuteNonQuery(string sql, params SqlParameter[] pms)
    {
        using (SqlConnection con = new SqlConnection(ConnectionStringLocalTransaction))
        {
            using (SqlCommand cmd = new SqlCommand(sql, con))
            {
                if (pms != null)
                {
                    cmd.Parameters.AddRange(pms);
                }
                con.Open();
                return cmd.ExecuteNonQuery();
            }
        }
    }

    //2.封装一个执行返回单个对象的方法：ExecuteScalar()
    public static object ExecuteScalar(string sql, params SqlParameter[] pms)
    {
        using (SqlConnection con = new SqlConnection(ConnectionStringLocalTransaction))
        {
            using (SqlCommand cmd = new SqlCommand(sql, con))
            {
                if (pms != null)
                {
                    cmd.Parameters.AddRange(pms);
                }
                con.Open();
                return cmd.ExecuteScalar();
            }
        }
    }


    //3.执行查询多行多列的数据的方法：ExecuteReader
    public static SqlDataReader ExecuteReader(string sql, params SqlParameter[] pms)
    {
        SqlConnection con = new SqlConnection(ConnectionStringLocalTransaction);
        using (SqlCommand cmd = new SqlCommand(sql, con))
        {
            if (pms != null)
            {
                cmd.Parameters.AddRange(pms);
            }
            try
            {
                con.Open();
                return cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception)
            {
                con.Close();
                con.Dispose();
                throw;
            }
        }
    }


    //4.执行返回DataTable的方法
    public static DataTable ExecuteDataTable(string sql, params SqlParameter[] pms)
    {
        DataTable dt = new DataTable();
        using (SqlDataAdapter adapter = new SqlDataAdapter(sql, ConnectionStringLocalTransaction))
        {
            if (pms != null)
            {
                adapter.SelectCommand.Parameters.AddRange(pms);
            }
            adapter.Fill(dt);
        }
        return dt;
    }
}