C# Excel操做類 ExcelHelper

　　實現C#與Excel文件的交互操做，實現如下功能：

　　一、DataTable 導出到 Excel文件

　　二、Model數據實體導出到 Excel文件[List<Model>]

　　三、導出數據到模版

　　四、多DataTable導入到同一Excel文件

　　　　對於第四項功能，常見的用途爲：最後一行顯示的是百分比，爲字符型，而這列其它類型爲數據型，若是放在同一個DataTable中，顯然不合適。此操做類可實現

　　五、將Excel文件導入到數據庫表中

　　　　能夠指定每一個字段的數據類型

 

　　此幫助類的代碼量不算少，但註釋比較詳細，導出數據集中在一個方法，導入數據集中在一個方法。只看完整的兩個方法就能夠了，其它方法爲便於使用所寫的輔助簡化方法，看看就清楚了：

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Reflection;
using System.Data.OleDb;

namespace SOSP.Common
{
    /// <summary>
    /// C#與Excel交互類
    /// </summary>
    public class ExcelHelper
    {
        #region 導出到Excel
        #region ExportExcelForDataTable
        /// <summary>
        /// 從DataTable導出Excel,指定列別名,指定要排除的列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="colName">各列的列名List string </param>
        /// <param name="excludeColumn">要顯示/排除的列</param>
        /// <param name="excludeType">顯示/排除列方式 0爲全部列 1指定的爲要顯示的列 2指定的爲要排除的列</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 例:tp.xlsx 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForDataTable(System.Data.DataTable dt, string excelPathName, string pathType, List<string> colName, List<string> excludeColumn, string excludeType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            try
            {
                if (dt == null || dt.Rows.Count == 0) return false;
                Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
                if (xlApp == null)
                {
                    return false;
                }
                System.Globalization.CultureInfo CurrentCI = System.Threading.Thread.CurrentThread.CurrentCulture;
                System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
                Microsoft.Office.Interop.Excel.Workbooks workbooks = xlApp.Workbooks;

                Microsoft.Office.Interop.Excel.Workbook workbook = null;
                if (TemplatePath == "")
                {
                    workbook = workbooks.Add(Microsoft.Office.Interop.Excel.XlWBATemplate.xlWBATWorksheet);
                }
                else
                {
                    workbook = workbooks.Add(TemplatePath); //加載模板
                }
                Microsoft.Office.Interop.Excel.Worksheet worksheet = (Microsoft.Office.Interop.Excel.Worksheet)workbook.Worksheets[1];
                Microsoft.Office.Interop.Excel.Range range;

                long totalCount = dt.Rows.Count;
                if (exDataTableList != null && exDataTableList.Count > 0)
                {
                    foreach (System.Data.DataTable item in exDataTableList)
                    {
                        totalCount += item.Rows.Count;
                    }
                }
                long rowRead = 0;
                float percent = 0;
                string exclStr = "";//要排除的列臨時項
                object exclType;//DataTable 列的類型,用於作
                int colPosition = 0;//列位置
                if (sheetName != null && sheetName != "")
                {
                    worksheet.Name = sheetName;
                }
                #region 列別名斷定
                if (TemplatePath == "")
                {
                    if (colName != null && colName.Count > 0)
                    {
                        #region 指定了列別名
                        for (int i = 0; i < colName.Count; i++)
                        {
                            worksheet.Cells[1, i + 1] = colName[i];
                            range = (Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1];
                            range.Interior.ColorIndex = 15;
                            range.Font.Bold = true;
                            exclType = dt.Columns[i].DataType.Name;
                            if (exclType.ToString() != "DateTime")
                            {
                                //range.EntireColumn.AutoFit();//全局自動調整列寬,不能再使用單獨設置
                                ((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.AutoFit();
                            }
                            else
                            {
                                //規定列寬
                                ((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.ColumnWidth = 20;
                            }
                            //((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.ColumnWidth = 20;
                        }
                        #endregion
                    }
                    else
                    {
                        #region 未指定別名
                        for (int i = 0; i < dt.Columns.Count; i++)
                        {
                            worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
                            range = (Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1];
                            range.Interior.ColorIndex = 15;
                            range.Font.Bold = true;
                            exclType = dt.Columns[i].DataType.Name;
                            if (exclType.ToString() != "DateTime")
                            {
                                //range.EntireColumn.AutoFit();//全局自動調整列寬,不能再使用單獨設置
                                ((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.AutoFit();
                            }
                            else
                            {
                                //規定列寬
                                ((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.ColumnWidth = 20;
                            }
                            //((Microsoft.Office.Interop.Excel.Range)worksheet.Cells[1, i + 1]).Columns.ColumnWidth = 20;
                        }
                        #endregion
                    }
                }
                else
                {
                    //用了模版，不加載標題
                }
                #endregion
                #region 顯示/排除列斷定
                if (excludeColumn != null && excludeColumn.Count > 0)
                {
                    switch (excludeType)
                    {
                        case "0":
                            {
                                #region 0爲顯示全部列
                                #region 常規項
                                int r = 0;
                                for (r = 0; r < dt.Rows.Count; r++)
                                {
                                    colPosition = 0;
                                    for (int i = 0; i < dt.Columns.Count; i++)
                                    {
                                        if (TemplatePath == "")
                                        {
                                            worksheet.Cells[r + 2, colPosition + 1] = dt.Rows[r][i].ToString();
                                        }
                                        else
                                        {
                                            worksheet.Cells[r + TemplateRow, colPosition + 1] = dt.Rows[r][i].ToString();
                                        }
                                        colPosition++;
                                    }
                                    rowRead++;
                                    percent = ((float)(100 * rowRead)) / totalCount;
                                }
                                #endregion
                                #region 擴展項
                                if (exDataTableList != null && exDataTableList.Count > 0)
                                {
                                    foreach (System.Data.DataTable item in exDataTableList)
                                    {
                                        for (int k = 0; k < item.Rows.Count; r++, k++)
                                        {
                                            colPosition = 0;
                                            //生成擴展 DataTable 每行數據
                                            for (int t = 0; t < item.Columns.Count; t++)
                                            {
                                                if (TemplatePath == "")
                                                {
                                                    worksheet.Cells[r + 2, colPosition + 1] = item.Rows[k][t].ToString();
                                                }
                                                else
                                                {
                                                    worksheet.Cells[r + TemplateRow, colPosition + 1] = item.Rows[k][t].ToString();
                                                }
                                                colPosition++;
                                            }
                                            rowRead++;
                                            percent = ((float)(100 * rowRead)) / totalCount;
                                        }
                                    }
                                }
                                #endregion
                                #endregion
                            }; break;
                        case "1":
                            {
                                #region 1指定的爲要顯示的列
                                #region 常規項
                                int r = 0;
                                for (r = 0; r < dt.Rows.Count; r++)
                                {
                                    colPosition = 0;
                                    for (int i = 0; i < dt.Columns.Count; i++)
                                    {
                                        exclStr = dt.Columns[i].ColumnName;
                                        if (excludeColumn.Contains(exclStr))
                                        {
                                            if (TemplatePath == "")
                                            {
                                                worksheet.Cells[r + 2, colPosition + 1] = dt.Rows[r][i].ToString();
                                            }
                                            else
                                            {
                                                worksheet.Cells[r + TemplateRow, colPosition + 1] = dt.Rows[r][i].ToString();
                                            }
                                            colPosition++;
                                        }
                                        else
                                        {

                                        }
                                    }
                                    rowRead++;
                                    percent = ((float)(100 * rowRead)) / totalCount;
                                }
                                #endregion
                                #region 擴展項
                                if (exDataTableList != null && exDataTableList.Count > 0)
                                {
                                    foreach (System.Data.DataTable item in exDataTableList)
                                    {
                                        for (int k = 0; k < item.Rows.Count; r++, k++)
                                        {
                                            colPosition = 0;
                                            //生成擴展 DataTable 每行數據
                                            for (int t = 0; t < item.Columns.Count; t++)
                                            {
                                                exclStr = dt.Columns[t].ColumnName;
                                                if (excludeColumn.Contains(exclStr))
                                                {
                                                    if (TemplatePath == "")
                                                    {
                                                        worksheet.Cells[r + 2, colPosition + 1] = item.Rows[k][t].ToString();
                                                    }
                                                    else
                                                    {
                                                        worksheet.Cells[r + TemplateRow, colPosition + 1] = item.Rows[k][t].ToString();
                                                    }
                                                    colPosition++;
                                                }
                                                else
                                                {

                                                }
                                            }
                                            rowRead++;
                                            percent = ((float)(100 * rowRead)) / totalCount;
                                        }
                                    }
                                }
                                #endregion
                                #endregion
                            }; break;
                        case "2":
                            {
                                #region 2指定的爲要排除的列
                                #region 常規項
                                int r = 0;
                                for (r = 0; r < dt.Rows.Count; r++)
                                {
                                    colPosition = 0;
                                    for (int i = 0; i < dt.Columns.Count; i++)
                                    {
                                        exclStr = dt.Columns[i].ColumnName;
                                        if (excludeColumn.Contains(exclStr))
                                        {

                                        }
                                        else
                                        {
                                            if (TemplatePath == "")
                                            {
                                                worksheet.Cells[r + 2, colPosition + 1] = dt.Rows[r][i].ToString();
                                            }
                                            else
                                            {
                                                worksheet.Cells[r + TemplateRow, colPosition + 1] = dt.Rows[r][i].ToString();
                                            }
                                            colPosition++;
                                        }
                                    }
                                    rowRead++;
                                    percent = ((float)(100 * rowRead)) / totalCount;
                                }
                                #endregion
                                #region 擴展項
                                if (exDataTableList != null && exDataTableList.Count > 0)
                                {
                                    foreach (System.Data.DataTable item in exDataTableList)
                                    {
                                        for (int k = 0; k < item.Rows.Count; r++, k++)
                                        {
                                            colPosition = 0;
                                            //生成擴展 DataTable 每行數據
                                            for (int t = 0; t < item.Columns.Count; t++)
                                            {
                                                exclStr = dt.Columns[t].ColumnName;
                                                if (excludeColumn.Contains(exclStr))
                                                {

                                                }
                                                else
                                                {
                                                    if (TemplatePath == "")
                                                    {
                                                        worksheet.Cells[r + 2, colPosition + 1] = item.Rows[k][t].ToString();
                                                    }
                                                    else
                                                    {
                                                        worksheet.Cells[r + TemplateRow, colPosition + 1] = item.Rows[k][t].ToString();
                                                    }
                                                    colPosition++;
                                                }
                                            }
                                            rowRead++;
                                            percent = ((float)(100 * rowRead)) / totalCount;
                                        }
                                    }
                                }
                                #endregion
                                #endregion
                            }; break;
                        default:
                            break;
                    }

                }
                else
                {
                    //生成每行數據
                    int r = 0;
                    for (r = 0; r < dt.Rows.Count; r++)
                    {
                        //生成每列數據
                        if (TemplatePath == "")
                        {
                            for (int i = 0; i < dt.Columns.Count; i++)
                            {
                                worksheet.Cells[r + 2, i + 1] = dt.Rows[r][i].ToString();
                            }
                        }
                        else
                        {
                            for (int i = 0; i < dt.Columns.Count; i++)
                            {
                                worksheet.Cells[r + 1 + TemplateRow, i + 1] = dt.Rows[r][i].ToString();
                            }
                        }
                        rowRead++;
                        percent = ((float)(100 * rowRead)) / totalCount;
                    }
                }
                #endregion
                switch (pathType)
                {
                    case "0": { workbook.Saved = false; }; break;
                    case "1": { workbook.Saved = true; workbook.SaveCopyAs(excelPathName); }; break;
                    default:
                        return false;
                }
                xlApp.Visible = false;//是否在服務器打開
                workbook.Close(true, Type.Missing, Type.Missing);
                workbook = null;
                xlApp.Quit();
                xlApp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 從DataTable導出Excel,指定列別名
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="colName">各列的列名List string </param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForDataTableC(System.Data.DataTable dt, string excelPathName, string pathType, List<string> colName, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> excludeColumn = new List<string>();
            string excludeType = "0";
            return ToExcelForDataTable(dt, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }

        /// <summary>
        /// 從DataTable導出Excel,指定要排除的列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="excludeColumn">要顯示/排除的列</param>
        /// <param name="excludeType">顯示/排除列方式 0爲全部列 1指定的爲要顯示的列 2指定的爲要排除的列</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForDataTableE(System.Data.DataTable dt, string excelPathName, string pathType, List<string> excludeColumn, string excludeType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> colName = new List<string>();
            return ToExcelForDataTable(dt, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }
        /// <summary>
        /// 從DataTable導出Excel，使用默認列名，不排除導出任何列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForDataTableZ(System.Data.DataTable dt, string excelPathName, string pathType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> colName = new List<string>();
            List<string> excludeColumn = new List<string>();
            string excludeType = "0";
            return ToExcelForDataTable(dt, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }
        #endregion

        #region ExportExcelForModelList
        /// <summary>
        /// 從DataTable導出Excel,指定列別名,指定要排除的列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="colName">各列的列名List string </param>
        /// <<param name="excludeColumn">要顯示/排除的列</param>
        /// <param name="excludeType">顯示/排除列方式 0爲全部列 1指定的爲要顯示的列 2指定的爲要排除的列</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForModelList<T>(List<T> md, string excelPathName, string pathType, List<string> colName, List<string> excludeColumn, string excludeType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            System.Data.DataTable dt = ModelListToDataTable(md);
            return ToExcelForDataTable(dt, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }

        /// <summary>
        /// 從DataTable導出Excel,指定列別名
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="colName">各列的列名List string </param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForModelListC<T>(List<T> md, string excelPathName, string pathType, List<string> colName, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> excludeColumn = new List<string>();
            string excludeType = "0";
            return ToExcelForModelList(md, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }

        /// <summary>
        /// 從DataTable導出Excel,指定要排除的列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="excludeColumn">要顯示/排除的列</param>
        /// <param name="excludeType">顯示/排除列方式 0爲全部列 1指定的爲要顯示的列 2指定的爲要排除的列</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForModelListE<T>(List<T> md, string excelPathName, string pathType, List<string> excludeColumn, string excludeType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> colName = new List<string>();
            return ToExcelForModelList(md, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }

        /// <summary>
        /// 從DataTable導出Excel，使用默認列名，不排除導出任何列
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <param name="excelPathName">含Excel名稱的保存路徑 在pathType＝1時有效，其它請賦值空字符串</param>
        /// <param name="pathType">路徑類型。只能取值：0客戶自定義路徑；1服務端定義路徑，標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名</param>
        /// <param name="sheetName">sheet1的名稱 爲空字符串時保持默認名稱</param>
        /// <param name="TemplatePath">模版在項目服務器中路徑 爲空字符串時表示無模版</param>
        /// <param name="TemplateRow">模版中已存在數據的行數，無模版時請傳入參數 0</param>
        /// <param name="exDataTableList">擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣</param>
        /// <returns>bool</returns>
        public static bool ToExcelForModelListZ<T>(List<T> md, string excelPathName, string pathType, string sheetName, string TemplatePath, int TemplateRow, List<System.Data.DataTable> exDataTableList)
        {
            List<string> colName = new List<string>();
            List<string> excludeColumn = new List<string>();
            string excludeType = "0";
            return ToExcelForModelList(md, excelPathName, pathType, colName, excludeColumn, excludeType, sheetName, TemplatePath, TemplateRow, exDataTableList);
        }
        #endregion

        #region 從DataTable導出Excel； ToExcelModel實體傳參
        /// <summary>
        /// 從DataTable導出Excel； ToExcelModel實體傳參
        /// </summary>
        /// <param name="tem">ExcelHelper.ToExcelModel</param>
        /// <returns></returns>
        public static bool ToExcelForDataTable(ToExcelModel tem)
        {
            if (tem != null)
            {
                return ToExcelForDataTable(tem.DataTable, tem.excelPathName, tem.pathType, tem.colNameList, tem.excludeColumn, tem.excludeType, tem.sheetName, tem.TemplatePath, tem.TemplateRow, tem.exDataTableList);
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region Model To DataTable
        /// <summary>
        /// 實體類轉換成DataTable
        /// </summary>
        /// <param name="modelList">實體類列表</param>
        /// <returns></returns>
        public static System.Data.DataTable ModelListToDataTable<T>(List<T> modelList)
        {
            System.Data.DataTable dtReturn = new System.Data.DataTable();

            // column names
            PropertyInfo[] oProps = null;

            if (modelList == null) return dtReturn;

            foreach (T rec in modelList)
            {
                if (oProps == null)
                {
                    oProps = ((Type)rec.GetType()).GetProperties();
                    foreach (PropertyInfo pi in oProps)
                    {
                        Type colType = pi.PropertyType;

                        if ((colType.IsGenericType) && (colType.GetGenericTypeDefinition()
                        == typeof(Nullable<>)))
                        {
                            colType = colType.GetGenericArguments()[0];
                        }

                        dtReturn.Columns.Add(new DataColumn(pi.Name, colType));
                    }
                }

                DataRow dr = dtReturn.NewRow();

                foreach (PropertyInfo pi in oProps)
                {
                    dr[pi.Name] = pi.GetValue(rec, null) == null ? DBNull.Value : pi.GetValue
                    (rec, null);
                }

                dtReturn.Rows.Add(dr);
            }
            return dtReturn;
        }
        #endregion

        #region 說明 如何使用
        /*
         * 功能：
         *      一、將System.Data.DataTable數據導出到Excel文件
         *      二、將Model(Entity)數據實體導出到Excel文件
         * 完整調用：
         *      一、ExcelHelper.ToExcelForDataTable(DataTable,excelPathName,pathType,colName,excludeColumn,excludeType,sheetName,TemplatePath,TemplateRow,exDataTableList);
         *      二、ExcelHelper.ToExcelForModelList(Model,excelPathName,pathType,colName,excludeColumn,excludeType,sheetName,TemplatePath,TemplateRow,exDataTableList);
         * 參數說明：
         *      一、DataTable：DataSet.DataTable[0];數據表
         *      二、Model：Model.Users users = new Model.Users(){...};數據實體
         *      三、excelPathName：含Excel名稱的保存路徑 在pathType＝1時有效。用戶自定義保存路徑時請賦值空字符串 ""。格式："E://456.xlsx"
         *      四、pathType：路徑類型。只能取值：0用戶自定義路徑，彈出用戶選擇路徑對話框；1服務端定義路徑。標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名，與excelPathName參數合用
         *      五、colName：各列的列別名List string，好比：字段名爲userName，此處可指定爲"用戶名"，並以此顯示
         *      六、excludeColumn：要顯示/排除的列，指定這些列用於顯示，或指定這些列用於不顯示。倒低這些列是顯示仍是不顯示，由excludeType參數決定
         *      七、excludeType：顯示/排除列方式。 0爲顯示全部列 1指定的是要顯示的列 2指定的是要排除的列，與excludeColumn合用
         *      八、sheetName：sheet1的名稱，要使期保持默認名稱請指定爲空字符串 ""
         *      九、TemplatePath：模版在項目服務器中路徑 例:tp.xlsx 。當爲空字符串 "" 時表示無模版
         *      十、TemplateRow：模版中已存在數據的行數，與TemplatePath合用，無模版時請傳入參數 0
         *      十一、exDataTableList：擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣
         * 注意：
         *      一、exDataTableList參數爲一個List<System.Data.DataTable> 集合，當數據爲 Model 時，可先調用 ExcelHelper.ModelListToDataTable(System.Data.DataTable dt)將Model轉爲System.Data.DataTable
         */
        #endregion
        #endregion
        #region 從Excel導入數據到 Ms Sql
        /// <summary>
        /// 從Excel導入數據到 Ms Sql
        /// </summary>
        /// <param name="excelFile">Excel文件路徑(含文件名)</param>
        /// <param name="sheetName">sheet名</param>
        /// <param name="DbTableName">存儲到數據庫中的數據庫表名稱</param>
        /// <param name="columnType">對應表格的數據類型，若是爲null，則爲默認類型：double,nvarchar(500),datetime</param>
        /// <param name="connectionString">鏈接字符串</param>
        /// <returns></returns>
        public static bool FromExcel(string excelFile, string sheetName, string DbTableName, List<string> columnType, string connectionString)
        {
            DataSet ds = new DataSet();
            try
            {
                //獲取所有數據   
                //string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + excelFile + ";" + "Extended Properties=Excel 8.0;";
                string strConn = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + excelFile + ";Extended Properties='Excel 12.0; HDR=Yes; IMEX=1'"; //此連
                #region 知識擴展
                //HDR=Yes，表明第一行是標題，不作爲數據使用。HDR=NO，則表示第一行不是標題，作爲數據來使用。系統默認的是YES
                //IMEX=0 只讀模式
                //IMEX=1 寫入模式
                //IMEX=2 可讀寫模式
                #endregion
                #region 命名執行
                using (OleDbConnection conn = new OleDbConnection(strConn))
                {
                    conn.Open();
                    string strExcel = "";
                    OleDbDataAdapter myCommand = null;
                    strExcel = string.Format("select * from [{0}$]", sheetName);
                    myCommand = new OleDbDataAdapter(strExcel, strConn);
                    myCommand.Fill(ds, sheetName);

                    #region 數據庫表是否存在的 T-SQL 檢測語句準備
                    //若是目標表不存在則建立   
                    string strSql = string.Format("if object_id('{0}') is null create table {0}(", DbTableName != "" ? DbTableName : sheetName);
                    if (columnType != null && columnType.Count > 0)
                    {
                        #region 手動指定定每一個字段的數據類型
                        //指定數據格式,要求一一對應
                        for (int i = 0; i < ds.Tables[0].Columns.Count; i++)
                        {
                            System.Data.DataColumn c = ds.Tables[0].Columns[i];
                            strSql += string.Format("[{0}] {1},", c.ColumnName, columnType[i]);
                        }
                        #endregion
                    }
                    else
                    {
                        #region 使用默認數據類型
                        foreach (System.Data.DataColumn c in ds.Tables[0].Columns)
                        {
                            //使用默認格式：只有double,DateTime,String三種類型
                            switch (c.DataType.ToString())
                            {
                                case "DateTime":
                                    {
                                        strSql += string.Format("[{0}] DateTime,", c.ColumnName);
                                    }; break;
                                case "Double":
                                    {
                                        strSql += string.Format("[{0}] double,", c.ColumnName);
                                    }; break;
                                default:
                                    strSql += string.Format("[{0}] nvarchar(500),", c.ColumnName);
                                    break;
                            }
                        }
                        #endregion
                    }
                    strSql = strSql.Trim(',') + ")";
                    #endregion
                    #region 執行 T-SQL 若是數據庫表不存在則新建表，若是存在則不新建
                    using (System.Data.SqlClient.SqlConnection sqlconn = new System.Data.SqlClient.SqlConnection(connectionString))
                    {
                        sqlconn.Open();
                        System.Data.SqlClient.SqlCommand command = sqlconn.CreateCommand();
                        command.CommandText = strSql;
                        command.ExecuteNonQuery();
                        sqlconn.Close();
                    }
                    #endregion
                    #region 向數據庫表插入數據
                    using (System.Data.SqlClient.SqlBulkCopy sbc = new System.Data.SqlClient.SqlBulkCopy(connectionString))
                    {
                        sbc.SqlRowsCopied += new System.Data.SqlClient.SqlRowsCopiedEventHandler(bcp_SqlRowsCopied);
                        sbc.BatchSize = 100;//每次傳輸的行數   
                        sbc.NotifyAfter = 100;//進度提示的行數   
                        sbc.DestinationTableName = DbTableName != "" ? DbTableName : sheetName;//數據庫表名錶名
                        sbc.WriteToServer(ds.Tables[0]);
                    }
                    #endregion
                }
                #endregion
            }
            catch (Exception ex)
            {
                return false;
            }
            return true;
        }
        #region 進度顯示
        /// <summary>
        /// 進度顯示
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        static void bcp_SqlRowsCopied(object sender, System.Data.SqlClient.SqlRowsCopiedEventArgs e)
        {
            e.RowsCopied.ToString();
        }
        #endregion
        #endregion
    }
    public class ToExcelModel
    {
        #region ToExcelModel自動屬性
        /// <summary>
        /// 數據表
        /// </summary>
        public System.Data.DataTable DataTable { get; set; }
        /// <summary>
        /// 含Excel名稱的保存路徑 在pathType＝1時有效。用戶自定義保存路徑時請賦值空字符串 ""。格式："E://456.xlsx"
        /// </summary>
        public string excelPathName { get; set; }
        /// <summary>
        /// 路徑類型。只能取值：0用戶自定義路徑，彈出用戶選擇路徑對話框；1服務端定義路徑。標識文件保存路徑是服務端指定仍是客戶自定義路徑及文件名，與excelPathName參數合用
        /// </summary>
        public string pathType { get; set; }
        /// <summary>
        /// 各列的列別名List string，好比：字段名爲userName，此處可指定爲"用戶名"，並以此顯示
        /// </summary>
        public List<string> colNameList { get; set; }
        /// <summary>
        /// 要顯示/排除的列，指定這些列用於顯示，或指定這些列用於不顯示。倒低這些列是顯示仍是不顯示，由excludeType參數決定
        /// </summary>
        public List<string> excludeColumn { get; set; }
        /// <summary>
        /// 顯示/排除列方式。 0爲顯示全部列 1指定的是要顯示的列 2指定的是要排除的列，與excludeColumn合用
        /// </summary>
        public string excludeType { get; set; }
        /// <summary>
        /// sheet1的名稱，要使期保持默認名稱請指定爲空字符串 ""
        /// </summary>
        public string sheetName { get; set; }
        /// <summary>
        /// 模版在項目服務器中路徑 例:tp.xlsx 。當爲空字符串 "" 時表示無模版
        /// </summary>
        public string TemplatePath { get; set; }
        /// <summary>
        /// 模版中已存在數據的行數，與TemplatePath合用，無模版時請傳入參數 0
        /// </summary>
        public int TemplateRow { get; set; }
        /// <summary>
        /// 擴展 DataTable List 用於當上下兩個及以上DataTable數據類型不一至,但又都在同一列時使用,要求格式與參數第一個 DataTable的列名字段名一至,僅字段類型可不一樣
        /// </summary>
        public List<System.Data.DataTable> exDataTableList { get; set; }
        #endregion
    }
    public class FromExcelModel
    {
        /// <summary>
        /// Excel文件路徑(含文件名)
        /// </summary>
        public string excelFile { get; set; }
        /// <summary>
        /// sheet名<
        /// </summary>
        public string sheetName { get; set; }
        /// <summary>
        /// 存儲到數據庫中的數據庫表名稱
        /// </summary>
        public string DbTableName { get; set; }
        /// <summary>
        /// 對應表格的數據類型，若是爲null，則爲默認類型：double,nvarchar(500),datetime
        /// </summary>
        public List<string> columnTypeList { get; set; }
        /// <summary>
        /// 鏈接字符串 server=serverip;database=databasename;uid=username;pwd=password;
        /// </summary>
        public string connectionString { get; set; }
    }
}

 

調用示例：

        /// <summary>
        /// 導出至Excel
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Button1_Click(object sender, EventArgs e)
        {
            try
            {
                BLL.COMMON_UserInfo cu = new BLL.COMMON_UserInfo();
                List<Model.COMMON_UserInfo> cuiList = cu.GetModelList("");
                BLL.manager_log bll = new BLL.manager_log();
                DataSet ds = bll.GetList(10, "", "id");
                System.Data.DataTable dt = ds.Tables[0];
                List<string> colName = new List<string>() { 
                "用戶ID",
                "用戶名",
                "備註",
                "用戶IP",
                "操做時間",
                "操做時間1",
                "操做時間2"
                };
                List<string> tt = new List<string>() { "action_type" };
                DataSet dss = bll.GetList(10, "", "id");
                List<System.Data.DataTable> dtss = new List<System.Data.DataTable>();
                dtss.Add(dss.Tables[0]);
                dtss.Add(dss.Tables[0]);
                dtss.Add(dss.Tables[0]);
                ExcelHelper.ToExcelForDataTable(dt, Server.MapPath("~").ToString() + "456.xlsx", "0", colName, tt, "2", "", "", 0, dtss);//指定了列別名，指定了要排除的列
                ToExcelModel tem = new ToExcelModel()
                {
                    DataTable = dt,
                    excelPathName = "",
                    pathType = "0",
                    colNameList = colName,
                    excludeColumn = tt,
                    excludeType = "0",
                    sheetName = "成功",
                    TemplatePath = "",
                    TemplateRow = 0,
                    exDataTableList = dtss
                };
                ExcelHelper.ToExcelForDataTable(tem);
            }
            catch (Exception ex)
            {
                FileLog.Log(ex.Message, "ExportExcelByDataTable");
            }
        }

View Code

        /// <summary>
        /// 導入數據到數據庫
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Button2_Click(object sender, EventArgs e)
        {
            string excelFile = "G://123.xls";
            string sheetName = "Sheet1";
            string DbTableName = "test_new_table";// "test_new_table";
            List<string> columnType = new List<string>() { 
                "int",
                "nvarchar(100)",
                "decimal(18,2)",
                "nvarchar(100)",
                "datetime"
            };
            string connectionString = "server=.;database=Test1;uid=sa;pwd=zhangquan;";
            ExcelHelper.FromExcel(excelFile, sheetName, DbTableName, columnType, connectionString);
        }

View Code