通用Excel导入设计

摘要：有时候我们的数据存放在Excel中（特别是对于用户来说更喜欢使用Excel收集一些常用数据），而系统又需要这些数据来处理其他业务，那么此时我们就需要将这些数据导入到数据库中。但是鉴于Excel的样式多种多样，因此每次导入时都必须书写很多重复的代码。很明显对于一个软件开发者做这些重复劳动是一件很无趣的事情。那么怎样来寻中一种通用的方法呢？今天我们就一块看一下如何来解决这个问题。

主要内容

1. Excel操作组件的选择
2. 总体设计思路
3. 配置文件设计
4. 类设计
5. 编码实现
6. 一点补充
7. 简单的测试
8. 总结

一、Excel操作组件的选择

在开始今天的主题之前我们先简单的看一个基础的问题，那就是如何进行Excel的读写。关于Excel的读写操作目前主要分为：1.Oledb数据库连接方式2.使用Excel.exe Com组件3.使用第三方控件。具体哪种方式好我们要依据具体情况而定，对于第一种方式则要求excel表格必须是像数据库中的表一样规范，例如如果excel牵扯到合并单元格的情况就很难处理了。对于第二种方式则要求用户必须安装Excel，而且其效率比较低。考虑到我们的需求，所以这里选择第三种方式来操作Excel。操作Excel的第三方控件比较多，常见的如NPOI、myxls、Aspose.Cells等。前两者都是开源的，并且NPOI除了写Excel功能比较强之外对于Excel读取也是十分优秀（myxls读取excel不如NPOI）。Aspose.Cells是一款商业控件，其操作方便性当然也是十分强大的，而且Aspose是一个系列组件，不仅有操作Excel的组件还有关于word、ppt、pdf、flash等操作组件。这里因为项目开发中使用的是Aspose.Cells，因此下面的例子中我们就拿Aspose.Cells来进行Excel操作（大家可以去找破解版或者使用NPOI，当然也可以用myxls等）。

二、总体设计思路

我们去设计通用Excel的目的就是为了避免重复工作，也就是说不必因为Excel的样式、数据等变化而重新从零做起、重复劳动。因此我们就必须抽取一个通用的东西出来，使用时只需要关注相关的业务而不必过度关注相关excel操作和存储。再简单一点就是封装共同点，暴漏个性点。考虑到这种情况，我们可以使用配置文件的方式来解决这个问题。在配置文件中我们配置Excle要导入的表、字段等信息，在进行导入时再依据配置文件将数据导入到数据库中。这样一来，在需要进行Excel导入时只需要为某个或多个excel配置一个xml文件，然后调用相关的类就可以完成整个excel导入工作了。

补充：通用的局限性

在这里说明一下，虽然我们设计的是一个通用的Excel导入程序，但是这里的"通用"只是相对来说的，并不是考虑了所有Excel的情况，因为Excel的设计情况十分的复杂多样，要将所有的情况都考虑进去是一个漫长的过程。我们这里的程序只考虑对于单sheet导入一个或多个表中的情况，并且不考虑包含统计行的情况（可以包含合并行、代码表字段等）。

三、配置文件设计

既然考虑使用xml配置的方式来设计通用Excel导入，因此如何设计好xml也就成了设计的重点。对于单表导入（一个Excel主要导入到一个数据库表中，当然这并不排除牵扯其他代码表的情况）我们的配置文件无论以数据库为基础设计（主要是依据数据库表结构）还是以Excel(主要是依据Excel格式设计)为基础设计都可以，但是如果是多表导入（也就是一个Excel可以导入到几张表中的情况）的话考虑其复杂性还是以数据库为基础更为合适。因此考虑到这种情况，我们整个配置设计会以数据库表结构为基础来设计。最终我们的设计样例如下：

<?xml version="1.0" encoding="utf-8" ?>
<Config EndTag="RowBlank" HeaderIndex="" DataIndex="">
  <Table Name="" DeleteRepeat="true" ExcludedColumns="" >  
    <Column IsPrimaryKey="" ColumnName="" HeaderText="" Required="true" DataType="number" DataLength="100" DefaultValue="" Comment="">
      <CodeTalbe Name="" PrimaryKey=""  ReferenceColumn="" Condition=""></CodeTalbe>
    </Column>
    
  </Table>
</Config>

在最外层为Config节点，代表整个配置。其属性EndTag(数据读取的结束标志，例如"RowBlank"代表空行结束，在读取Excel时遇到某行没有任何数据的情况则视为结束；也可以为某个列地址，在导入时到了此列就会结束导入操作)；属性HeaderIndex代表excel表头对应的行值（从1开始）；DataIndex表示数据列起始行索引（从1开始）。

接着是Table节点，对应数据库中的表，可以有多个。其Name属性对应要导入的表名称；DeleteRepeat属性表示是否删除重复行（如果为true则会根据主键先删除重复行再执行插入操作）；ExcludedColumns表示排除列，多个列名使用"，"分割（这些字段不会导入）。

Table节点内当然就是Column节点，也就是对应的列，通常有多个（注意对于excel中没有的列，而数据库表需要导入的，也需要配置Column节点，此时HeaderText为空或不配置HeaderText属性）。IsPrimarykey属性表示是否为主键（当Table节点配置DeleteRepeat为ture时必须指定一个Column节点的IsPrimaryKey为true，因为此属性是为了delete条件做准备的[有可能它不是真正的主键]）；ColumnName表示对应的列名；HeaderText表示对应的Excel列头（在依据Excel别名导入时根据此值确定导入的列）；Required指定此列是否为必须导入的列（如果配置为true，excel中此列为空并且没有配置默认值的话则会抛出异常）；DataType为数据类型（例如string、number，用于数据校验）；DefaultValue为默认值（注意其值不一定是指定的字符值，可以是"Max"、"NewID".如果为Max，那么此列必须为数值类型，此时在导入的时候如果需要使用默认值，就会在原来数据库表中此列最大值的基础上加上1导入到数据库中，如果为NewID在导入的时候如果需要使用默认值系统就会自动创建id）；Comment是此列的说明。

在Column节点中还可以配置CodeTable节点，表示代码表。Name属性值主表的表名称；PrimaryKey指主表的主键，也就是字表的外键；ReferenceColumn表示对应代码字段关联名称列，也就是我们导入时所依据的excel对应值（例如CategoryID对应CategoryName，那么ReferenceColumn就是CategoryName，因为往往Excel中可能存放的是类似于CategoryName的东西而不是CategoryID，而导入操作时需要CategoryID）。

四、类设计

我们有了思路之后，接下来就来看一下类的设计吧。

在这些类中Excel类是整个导入的核心，其最初要的方法就是Import()，当然除此之外所有对于Excel的读取和对数数据库的操作以及对配置对象的解析都是由此类负责；Config类是对整个配置的抽象，其对应的方法图中也已经标出，每个Config类对应多个实体类；Entity是对于表的抽象，就是表对应的实体类；Property类是对于列的抽象，每个Entity中包含多个Property；另外DictionaryEntity是数据字典，是对代码表的抽象，每个Property可以对应一个代码表；除此之外ConfigHelper是对于应用程序配置的封装；AsposeCell是对Aspose.Cells的封装，包含常用的Excel读写方法。

五、编码实现

接下来我们就开始实现整个设计吧，相信有了上面的说明和代码中的注释，理解起来应该很简单的，我就不再过多赘余了。

AsposeCell类

using System;
using System.Collections.Generic;
using System.Text;
using Aspose.Cells;
namespace Cmj.DataExchange
{
    //Aspose帮助类，对常用Aspose用法进行封装
    public class AsposeCell
    {
        private Workbook _workbook = null;
        private Dictionary<string,Worksheet> _worksheets = null;
        private Worksheet _currentWorksheet = null;
        public AsposeCell(string fullName)
        {
            _workbook = new Workbook();
            _workbook.Open(fullName);
            _worksheets = new Dictionary<string, Worksheet>();
            foreach (Worksheet worksheet in _workbook.Worksheets)
            {
                _worksheets.Add(worksheet.Name, worksheet);
            }
            _currentWorksheet = _workbook.Worksheets[0];
        }
        //设置指定名称的sheet为当前操作sheet
        public void SetCurrentWorksheet(string worksheetName)
        {
            if (_worksheets.ContainsKey(worksheetName))
            {
                _currentWorksheet = _worksheets[worksheetName];
            }
            else
            {
                throw new Exception("当前工作薄不存在/""+worksheetName+"/"工作表！");
            }
        }
        //设置指定索引（从0开始）的sheet为当前操作sheet
        public void SetCurrentWorksheet(byte worksheetIndex)
        {
            if (worksheetIndex <= _worksheets.Count)
            {
                _currentWorksheet = GetWorkSheetByIndex(worksheetIndex);
            }
            else
            {
                throw new Exception("工作表索引范围超过了总工作表数量！");
            }
        }
        //根据索引得到sheet
        public Worksheet GetWorkSheetByIndex(byte index)
        {
            byte i = 0;
            Worksheet worksheet = null;
            foreach(string name in _worksheets.Keys)
            {
                if (index == i)
                {
                    worksheet = _worksheets[name];
                }
                i++;
            }
            return worksheet;
        }
        //根据sheet名称得到sheet
        public Worksheet GetWorkSheetByName(string sheetName)
        {
            if (_worksheets.ContainsKey(sheetName))
            {
                return _worksheets[sheetName];
            }
            else
            {
                return null;
            }
            
        }
        /// <summary>
        /// 判断指定行是否有数据
        /// </summary>
        /// <param name="row">从1开始，为Excel行序号</param>
        /// <returns></returns>
        public bool RowHasValue(int row)//指定行是否有数据（以连续50列没有数据为标准）
        {
            bool r = false;
            for (int i = 0; i < 50; ++i)
            {
                if (_currentWorksheet.Cells[row - 1, i].Value != null && _currentWorksheet.Cells[row - 1, i].Value.ToString() != "")
                {
                    r = true;
                    break;
                }
            }
            return r;
        }
        public bool RowHasValue(string position)//指定行是否有数据（以连续50列没有数据为标准）
        {
            bool r = false;
            for (int i = 0; i < 50; ++i)
            {
                if (GetCellValue(position)!="")
                {
                    r = true;
                    break;
                }
            }
            return r;
        }
        //取得指定sheet中指定cell位置的数据
        public string GetCellValue(string worksheetName, string cellName)
        {
            return _worksheets[worksheetName].Cells[cellName].Value != null ? _worksheets[worksheetName].Cells[cellName].Value.ToString() : "";
        }
        public string GetCellValue(byte worksheetIndex, string cellName)
        {
            return GetWorkSheetByIndex(worksheetIndex).Cells[cellName].Value != null ? GetWorkSheetByIndex(worksheetIndex).Cells[cellName].Value.ToString() : "";
        }
        public string GetCellValue(string cellName)
        {
            return _currentWorksheet.Cells[cellName].Value != null ? _currentWorksheet.Cells[cellName].Value.ToString() : "";
        }
        /// <summary>
        /// 根据行列索引得到指定位置的数据
        /// </summary>
        /// <param name="row">从0开始</param>
        /// <param name="column">从0开始</param>
        /// <returns></returns>
        public string GetCellValue(int row, int column)
        {
            return _currentWorksheet.Cells[row, column].Value != null ? _currentWorksheet.Cells[row, column].Value.ToString() : "";
        }
        /// <summary>
        /// 判断某位置的单元格是否为合并单元格
        /// </summary>
        /// <param name="row">从0开始</param>
        /// <param name="column">从0开始</param>
        /// <returns></returns>
        public bool IsMerged(int row,int column)
        {
            return _currentWorksheet.Cells[row, column].IsMerged;
        }
        //取得合并单元格的数据
        public string GetMergedCellValue(int row, int column)//事实上合并单元格只有第一个单元格有值其他的全为空，但是我们知道其实从意义上理解合并单元格除了第一个单元格外其他单元格的值同第一个，因此这里提供这样一个方法
        {
            string r = "";
            int t=row-1;
            if (IsMerged(row, column))
            {
                if (GetCellValue(row, column) != "")
                {
                    r = GetCellValue(row, column);
                }
                else//约定合并单元格只是合并行并不和并列，并且合并行数最多50
                {
                    while (t >= 0 && (row-t)<50)
                    {
                        if (GetCellValue(t, column) != "")
                        {
                            r = GetCellValue(t, column);
                            break;
                        }
                        t--;
                    }
                }
            }
            return r;
        }
        //取得Range名称集合
        public List<string> GetRangeNames()
        {
            List<string> names = new List<string>();
            foreach (Range r in _workbook.Worksheets.GetNamedRanges())
            {
                names.Add(r.Name);
            }
            return names;
        }
        //取得某行Range名称集合
        public List<string> GetRangeNames(int rowIndex)
        {
            List<string> names = new List<string>();
            if (_workbook.Worksheets.GetNamedRanges()!=null)
            {
                foreach (Range r in _workbook.Worksheets.GetNamedRanges())
                {
                    if (r.FirstRow == rowIndex && r.Worksheet == _currentWorksheet)
                    {
                        names.Add(r.Name);
                    }
                }
            }
            return names;
        }
        //根据Range（别名）取得行索引
        public int GetRowIndexByRangeName(string rangeName)//只返回第一行索引（从0开始）
        {
            if (_workbook.Worksheets.GetRangeByName(rangeName) != null)
            {
                return _workbook.Worksheets.GetRangeByName(rangeName).FirstRow;
            }
            else
            {
                throw new Exception("未有找到指定名称的单元格！");
            }
        }
        //根据Range（别名）取得列索引
        public int GetColumnIndexByRangeName(string rangeName)//只返回第一行索引（从0开始）
        {
            if (_workbook.Worksheets.GetRangeByName(rangeName) != null)
            {
                return _workbook.Worksheets.GetRangeByName(rangeName).FirstColumn;
            }
            else
            {
                throw new Exception("未有找到指定名称的单元格！");
            }
        }
        //根据Range(别名)取得行列索引
        public int[] GetRowAndColumnIndexByRangeName(string rangeName)
        {
            int[] i = new int[2];
            if (_workbook.Worksheets.GetRangeByName(rangeName) != null)
            {
                i[0] = _workbook.Worksheets.GetRangeByName(rangeName).FirstRow;
                i[1]=_workbook.Worksheets.GetRangeByName(rangeName).FirstColumn;
                return i;
            }
            else
            {
                throw new Exception("未有找到指定名称的单元格！");
            }
        }
    }
}

ConfigHelper类

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
namespace Cmj.DataExchange
{
    //配置辅助类，主要用于读取应用程序配置文件
    internal class ConfigHelper
    {
        private static ConfigHelper configHelper = null;
        private static object obj = new object();
        private string excelPath = "";//Excel文件所在路径或者其根目录（此时会将其下所有excel全部倒入）
        private bool useTransaction = false;
        private ConfigHelper()
        {
            //读取excel配置路径
            if (ConfigurationManager.AppSettings["ExcelPath"] != null)
            {
                excelPath = ConfigurationManager.AppSettings["ExcelPath"];
            }
            else
            {
                throw new Exception("未发现Excel配置路径（ExcelPath），请检查配置文件！");
            }
            if (ConfigurationManager.AppSettings["useTransaction"] != null)
            {
                useTransaction = Convert.ToBoolean(ConfigurationManager.AppSettings["useTransaction"]);
            }
        }
        public static ConfigHelper Instance()
        {
            lock (obj)
            {
                if (configHelper == null)
                {
                    configHelper = new ConfigHelper();
                }
            }
            return configHelper;
        }
        public string ExcelPath
        {
            get
            {
                return excelPath;
            }
            set
            {
                excelPath = value;
            }
        }
        public bool UseTransaction
        {
            get
            {
                return useTransaction;
            }
            set
            {
                useTransaction = value;
            }
        }
    }
}

DictionaryEntity类

using System;
using System.Collections.Generic;
using System.Text;
namespace Cmj.DataExchange
{
    //代码表类，是对CodeTable的抽象
    internal class DictionaryEntity
    {
        private string name = "";//代码表名称，对应数据库中主表名称
        private string primaryKey = "";//代码表主键，也就是字表的对应外键
        private string referenceColumn = "";//代码字段关联名称列，也就是我们导入时所依据的excel对应值
        private string condition = "";//相关条件
        public DictionaryEntity()
        {
        }
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        public string PrimaryKey
        {
            get
            {
                return primaryKey;
            }
            set
            {
                primaryKey = value;
            }
        }
        public string ReferenceColumn
        {
            get
            {
                return referenceColumn;
            }
            set
            {
                referenceColumn = value;
            }
        }
        public string Condition
        {
            get
            {
                return condition;
            }
            set
            {
                condition = value;
            }
        }
    }
}

Property类

using System;
using System.Collections.Generic;
using System.Text;
namespace Cmj.DataExchange
{
    //配置属性类，抽象了配置文件的配置属性，对应于数据库中的字段
    internal class Property
    {
        private bool isPrimaryKey=false;//是否为主键
        private string columnName = "";//数据库列名称
        private string headerText = "";//对应的excel列头名称
        private bool required = true;//是否为必填字段
        private string dataType = "string";//数据类型（默认为string类型）
        private int dataLength = 5000;//数据长度（默认为5000）
        private string defaultValue = "";//默认值(对应excel此列的值如果为空则会使用此值来导入)
        private string comment = "";//字段说明信息（非必要属性）
        private DictionaryEntity codeTalbe = null;//对应的代码表
        public Property()
        {
        }
        public bool IsPrimaryKey
        {
            get
            {
                return isPrimaryKey;
            }
            set
            {
                isPrimaryKey = value;
            }
        }
        public string ColumnName
        {
            get
            {
                return columnName;
            }
            set
            {
                columnName = value;
            }
        }
        public string HeaderText
        {
            get
            {
                return headerText;
            }
            set
            {
                headerText = value;
            }
        }
        public bool Required
        {
            get
            {
                return required;
            }
            set
            {
                required = value;
            }
        }
        public string DataType
        {
            get
            {
                return dataType;
            }
            set
            {
                dataType = value;
            }
        }
        public int DataLength
        {
            get
            {
                return dataLength;
            }
            set
            {
                dataLength = value;
            }
        }
        public string DefaultValue//解析过的默认值（也就是说直接就是值，而不是其地址什么的）
        {
            get
            {
                return defaultValue;
            }
            set
            {
                defaultValue = value;
            }
        }
        public string Comment//说明信息
        {
            get
            {
                return comment;
            }
            set
            {
                comment = value;
            }
        }
        public DictionaryEntity CodeTable//代码表
        {
            get
            {
                return codeTalbe;
            }
            set
            {
                codeTalbe = value;
            }
        }
    }
}

Entity类

using System;
using System.Collections.Generic;
using System.Text;
namespace Cmj.DataExchange
{
    //实体类，对配置文件中Table的抽象，对应数据库中的表
    internal class Entity
    {
        private string name = "";//表名称
        private bool deleteRepeat = false;//是否删除重复（默认为false，如果设为true则在插入时首先根据主键删除重复信息）
        private List<Property> propertys = null;//属性集合（每个实体对应多个Property）
        private List<string> excludedColumns = null;//排除字段（也就是指明哪些字段不用导入）
        public Entity()
        {
            propertys = new List<Property>();
            excludedColumns = new List<string>();
        }
        public Entity(string name)
        {
            this.name=name;
            excludedColumns = new List<string>();
            propertys = new List<Property>();
        }
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        public bool DeleteRepeat
        {
            get
            {
                return deleteRepeat;
            }
            set
            {
                deleteRepeat = value;
            }
        }
        public List<string> ExcludedColumns
        {
            get
            {
                return excludedColumns;
            }
            set
            {
                excludedColumns = value;
            }
        }
        public List<Property> Propertys
        {
            get
            {
                return propertys;
            }
            set
            {
                propertys = value;
            }
        }
    }
}

Config类

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Xml;
using Cmj.MyFile;
namespace Cmj.DataExchange
{
    //配置类，是对整个配置的抽象
    internal class Config
    {
        #region　excel读取相关成员变量
        private MyXML xml = null;
        #endregion
        #region 配置文件相关成员变量
        private string endFlag = "RowBlank";//Excel结束标志
        private byte headerIndex = 1;//列头所在行
        private byte dataIndex = 2;//数据行起始位置
        private List<Entity> entities = null;//配置类对应的实体类（也就是说配置时，每个Config节点中可以有多个Table节点）
        #endregion
        public Config(string excelConfigFullName)
        {
            //初始化成员变量
            entities = new List<Entity>();
            //读取配置文件，类初始化
            Init(excelConfigFullName);
        }
        public string EndFlag
        {
            get
            {
                return endFlag;
            }
        }
        public int HeaderIndex
        {
            get
            {
                return headerIndex;
            }
        }
        public int DataIndex
        {
            get
            {
                return dataIndex;
            }
        }
        public List<Entity> Entities
        {
            get
            {
                return entities;
            }
        }
        //初始化配置对象
        private void Init(string excelConfigFullName)
        {
            int t = 1;
            bool r = true;
            xml = new MyXML(excelConfigFullName);
            endFlag = xml.GetSingleNodeAttribute("Config", "EndFlag") != "" ? xml.GetSingleNodeAttribute("Config", "EndFlag") : "RowBlank";//默认判断是否读取结束的标志设为“RowBlank”，也就是空行。
            r = int.TryParse(xml.GetSingleNodeAttribute("Config", "HeaderIndex"), out t);
            if (r)
            {
                headerIndex = Convert.ToByte(xml.GetSingleNodeAttribute("Config", "HeaderIndex"));
            }
            r = int.TryParse(xml.GetSingleNodeAttribute("Config", "DataIndex"), out t);
            if (r)
            {
                dataIndex = Convert.ToByte(xml.GetSingleNodeAttribute("Config", "DataIndex"));
            }
            if (MyFilleBase.FileBeing(excelConfigFullName))//根据完整路径判断文件是否存在
            {
                AddEnities(excelConfigFullName);
            }
            else
            {
                throw new Exception("相应配置文件未找到，请检查相应文件是否存在！");
            }
        }
        //初始化实体对象
        private void AddEnities(string fullName)
        {
            xml = new MyXML(fullName);
            XmlNodeList tables = xml.GetNodes("Config/Table");
            Entity entity = null;
            Property property = null;
            bool t = true;
            bool r=true;
            int i = 0;
            foreach (XmlNode table in tables)
            {
                entity = new Entity(xml.GetNodeAttribute(table,"Name"));
                r = bool.TryParse(xml.GetNodeAttribute(table, "DeleteRepeat"),out t);
                if (r)
                {
                    entity.DeleteRepeat = Convert.ToBoolean(xml.GetNodeAttribute(table, "DeleteRepeat"));
                }
                if (xml.GetFirstChildNode(table) != null)//说明有列配置
                {
                    foreach (XmlNode column in xml.GetChildNodes(table))
                    {
                        property = new Property();
                        r = bool.TryParse(xml.GetNodeAttribute(column, "IsPrimaryKey"), out t);
                        if (r)
                        {
                            property.IsPrimaryKey = Convert.ToBoolean(xml.GetNodeAttribute(column, "IsPrimaryKey"));
                        }
                        property.ColumnName = xml.GetNodeAttribute(column, "ColumnName");
                        if (xml.GetNodeAttribute(column, "HeaderText") != "")
                        {
                            property.HeaderText = xml.GetNodeAttribute(column, "HeaderText");
                        }
                        r = bool.TryParse(xml.GetNodeAttribute(column, "Required"), out t);
                        if (r)
                        {
                            property.Required = Convert.ToBoolean(xml.GetNodeAttribute(column, "Required"));
                        }
                        property.DataType = xml.GetNodeAttribute(column, "DataType") != "" ? xml.GetNodeAttribute(column, "DataType") : "string";
                        if (xml.GetNodeAttribute(column, "DataLength") != "")
                        {
                            r = int.TryParse(xml.GetNodeAttribute(column, "DataLength"),out i);
                            if (r)
                            {
                                property.DataLength = i;
                            }
                        }
                        property.Comment = xml.GetNodeAttribute(column, "Comment");
                        property.DefaultValue = xml.GetNodeAttribute(column, "DefaultValue") != "" ? xml.GetNodeAttribute(column, "DefaultValue") : "";
                        if (xml.GetFirstChildNode(column) != null)//说明有代码表
                        {
                            DictionaryEntity dictionaryEntity = new DictionaryEntity();
                            dictionaryEntity.Name = xml.GetNodeAttribute(xml.GetFirstChildNode(column), "Name");
                            dictionaryEntity.PrimaryKey = xml.GetNodeAttribute(xml.GetFirstChildNode(column), "PrimaryKey");
                            dictionaryEntity.ReferenceColumn = xml.GetNodeAttribute(xml.GetFirstChildNode(column), "ReferenceColumn");
                            dictionaryEntity.Condition = xml.GetNodeAttribute(xml.GetFirstChildNode(column), "Condition");
                            property.CodeTable = dictionaryEntity;
                        }
                        entity.Propertys.Add(property);
                    }
                    entities.Add(entity);
                }
                else
                {
                    string excludedColumns = xml.GetNodeAttribute(table, "ExcludedColumns");
                    if (excludedColumns != "")
                    {
                        foreach (string ec in excludedColumns.Split(','))
                        {
                            entity.ExcludedColumns.Add(ec);
                        }
                    }
                    entities.Add(entity);
                }
                
            }
        }
    }
}

Excel类

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using Cmj.MyFile;
using Cmj.MyData;
namespace Cmj.DataExchange
{
    //Excel导入核心类
    public class Excel
    {
        private Dictionary<string, Config> configs =null;//配置文件全路径和对应的配置类键值集合
        private string excelPath="";//excel路径（可以为目录）
        bool useTransaction=false;//是否使用事务
        private AsposeCell asposeCell = null;//Aspose.Cells封装类
        private SqlHelper dbHelper = new SqlHelper();//数据库操作封装类
        public Excel()
        {
            excelPath=ConfigHelper.Instance().ExcelPath;
            useTransaction = ConfigHelper.Instance().UseTransaction;
            InitConfig();
        }
        public Excel(string excelPath,bool useTransaction)
        {
            this.excelPath=excelPath;
            this.useTransaction = useTransaction;
            ConfigHelper.Instance().ExcelPath = excelPath;
            ConfigHelper.Instance().UseTransaction = useTransaction;
            InitConfig();
        }
        //导入操作核心方法，负责整个Excel导入
        public void Import()
        {
            if (configs.Count > 0)
            {
                if (useTransaction)//使用事务的情况
                {
                    dbHelper.TransationHandler(SqlHelper.TransationType.Open);
                    ExcuteImport();
                    dbHelper.TransationHandler(SqlHelper.TransationType.Complete);
                }
                else
                {
                    ExcuteImport();
                }
            }
            else
            {
                throw new Exception("Config对象个数为0，无法导入！");
            }
        }
        //执行Excel导入
        private void ExcuteImport()
        {
            string sqlDelete = "";//删除操作对应的sql语句
            string sqlInsert = "";//插入操作使用的sql语句
            int headerIndex = 1;//列头所在行
            int dataIndex = 2;//数据起始行
            string endFlag = "RowBlank";
            foreach (string excelFullName in configs.Keys)//遍历所有config
            {
                asposeCell = new AsposeCell(excelFullName);
                List<Entity> entities = configs[excelFullName].Entities;//注意每个config中不一定只有一个实体，可以配置多个，这样每个excel可以导入到多张表中
                headerIndex = configs[excelFullName].HeaderIndex;
                dataIndex = configs[excelFullName].DataIndex;
                endFlag = configs[excelFullName].EndFlag;
                while (!IsEnd(asposeCell, endFlag, dataIndex))
                {
                    foreach (Entity entity in entities)
                    {
                        if (entity.Propertys.Count > 0)//说明配置了Column字段
                        {
                            if (entity.DeleteRepeat)
                            {
                                sqlDelete = "delete from " + entity.Name + " where " + GetSqlConditionString(asposeCell, entity, headerIndex, dataIndex);
                                dbHelper.ExcuteNonQuery(CommandType.Text, sqlDelete);
                            }
                            sqlInsert = "insert into " + entity.Name + "(" + GetSqlFieldString(asposeCell, entity) + ")" + " Values(" + GetSqlFieldValueString(asposeCell, entity, headerIndex, dataIndex) + ")";
                            dbHelper.ExcuteNonQuery(CommandType.Text, sqlInsert);
                        }
                        else
                        {
                            if (asposeCell.GetRangeNames(headerIndex - 1).Count > 0)//说明指定了单元格别名作为列名
                            {
                                sqlInsert = "insert into " + entity.Name + "(" + GetSqlFieldStringAccordingToAlias(asposeCell, headerIndex) + ") values(" + GetSqlFieldValueStringAccordingToAlias(asposeCell, headerIndex, dataIndex) + ")";
                            }
                            else if (entity.ExcludedColumns.Count > 0)//说明有排除字段
                            {
                                sqlInsert = "insert into " + entity.Name + "(" + GetSqlFieldStringAccordingToExcludedColumns(asposeCell, entity) + ") values(" + GetSqlFieldValueStringWithoutAlias(asposeCell, entity, headerIndex, dataIndex) + ")";
                            }
                            else
                            {
                                sqlInsert = "insert into " + entity.Name + " values(" + GetSqlFieldValueStringWithoutAlias(asposeCell, entity, headerIndex, dataIndex) + ")";
                            }
                            dbHelper.ExcuteNonQuery(CommandType.Text, sqlInsert);
                        }
                    }
                    dataIndex++;
                }
            }
        }
        /// <summary>
        /// 根据EndFlag标记判断当前数据行是否结束
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="endFlag"></param>
        /// <param name="row"></param>
        /// <returns></returns>
        private bool IsEnd(AsposeCell asposeCell,string endFlag,int row)
        {
            bool r = false;
            switch (endFlag)
            {
                case "RowBlank":
                    if (!asposeCell.RowHasValue(row))
                    {
                        r = true;
                    }
                    break;
                default :
                    if (asposeCell.GetCellValue(endFlag+row.ToString()) == "")
                    {
                        r = true;
                    }
                    break;
            }
            return r;
        }
        /// <summary>
        /// 根据HeaderText配置节确定列索引（从0开始）
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="headerIndex"></param>
        /// <param name="headerText"></param>
        /// <returns></returns>
        private int GetColumnIndexByHeaderText(AsposeCell asposeCell,int headerIndex,string headerText)
        {
            int columnIndex=0;
            int r=0;
            while (asposeCell.GetCellValue(headerIndex-1, columnIndex) != "")
            {
                if (asposeCell.GetCellValue(headerIndex-1, columnIndex) == headerText)
                {
                    r = columnIndex;
                }
                columnIndex++;
            }
            return r;
        }
        /// <summary>
        /// 根据DefaultValue配置节确定默认值
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="entityName"></param>
        /// <param name="columnName"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        private string GetDefaultValue(AsposeCell asposeCell,string entityName,string columnName, string defaultValue)
        {
            string r = "";
            switch (defaultValue)
            {
                case "NewID": r = Guid.NewGuid().ToString(); break;
                case "Max": r = dbHelper.ExecuteScalar(CommandType.Text, "select max(" + columnName + ") from " + entityName + "") != null ?((Convert.ToInt32(dbHelper.ExecuteScalar(CommandType.Text,"select max(" + columnName + ") from " + entityName + "").ToString())+1).ToString()) : "1"; break;
                default: r = defaultValue; break;
            }
            return r;
        }
        /// <summary>
        /// 得到查询条件sql语句段
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="entity"></param>
        /// <param name="headerIndex"></param>
        /// <param name="dataIndex"></param>
        /// <returns></returns>
        private string GetSqlConditionString(AsposeCell asposeCell, Entity entity,int headerIndex,int dataIndex)
        {
            string sql="";
            foreach (Property p in entity.Propertys)
            {
                if(p.IsPrimaryKey)
                {
                    sql+=p.ColumnName+"=";
                    if (p.HeaderText!="")
                    {
                        sql+="'"+asposeCell.GetCellValue(dataIndex-1,GetColumnIndexByHeaderText(asposeCell,headerIndex,p.HeaderText))+"'";
                    }
                    else
                    {
                        sql += "'"+GetDefaultValue(asposeCell, entity.Name, p.ColumnName, p.DefaultValue)+"'";
                    }
                    sql += " and";
                }
            }
            sql = sql.Substring(0, sql.Length - 4);
            return sql;
        }
        /// <summary>
        /// 得到查询字段sql语句段
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        private string GetSqlFieldString(AsposeCell asposeCell,Entity entity)
        {
            string sql = "";
            foreach (Property p in entity.Propertys)
            {
                sql += p.ColumnName+",";
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        /// <summary>
        /// 依据别名得到查询字段sql段
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <returns></returns>
        private string GetSqlFieldStringAccordingToAlias(AsposeCell asposeCell,int headerIndex)
        {
            string sql = "";
            foreach (string columnName in asposeCell.GetRangeNames(headerIndex - 1))
            {
                sql += columnName + ",";
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        /// <summary>
        /// 依据排除列得到查询字段sql语句段
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="headerIndex"></param>
        /// <returns></returns>
        private string GetSqlFieldStringAccordingToExcludedColumns(AsposeCell asposeCell, Entity entity)
        {
            string sql = "";
            foreach(DataColumn column in dbHelper.GetDataTable(CommandType.Text,"select top 0 * from "+entity.Name).Columns)
            {
                if (!entity.ExcludedColumns.Contains(column.ColumnName))
                {
                    sql += column.ColumnName + ",";
                }
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        /// <summary>
        /// 得到查询值sql语句段
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="entity"></param>
        /// <param name="headerIndex"></param>
        /// <param name="dataIndex"></param>
        /// <returns></returns>
        private string GetSqlFieldValueString(AsposeCell asposeCell, Entity entity,int headerIndex, int dataIndex)
        {
            string sql = "";
            string v = "";
            foreach (Property p in entity.Propertys)//遍历实体的所有属性
            {
                if (p.CodeTable != null)
                {
                    sql += "'" + GetCodeTableValue(asposeCell,p,headerIndex,dataIndex).Replace("'","''") + "',";//注意如果单元格本身的值就有“'”的情况
                }
                else//说明此属性是一个代码表字段
                {
                    if(asposeCell.IsMerged(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, p.HeaderText)))//是否为合并单元格(对于合并单元格取此合并单元格的第一个值)
                    {
                        v=asposeCell.GetMergedCellValue(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, p.HeaderText));
                    }
                    else
                    {
                        v=asposeCell.GetCellValue(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, p.HeaderText));
                    }
                    if (v == "")//说明单元格中没有任何值，就要考虑“默认值”和“必须”属性
                    {
                        if (GetDefaultValue(asposeCell, entity.Name, p.ColumnName, p.DefaultValue) != "")//说明有默认值
                        {
                            v = GetDefaultValue(asposeCell, entity.Name, p.ColumnName, p.DefaultValue);
                        }
                        else//如果单元格没有值并且无默认值，则检查此属性是否是必须的
                        {
                            if (!p.Required)
                            {
                                v = "";
                            }
                            else
                            {
                                throw new Exception("列/""+p.HeaderText+"/""+"不能为空！");
                            }
                        }
                    }
                    //检查类型
                    if (p.DataType != "" && p.DataType != "string")
                    {
                        if (!ValidateDataType(v, p.DataType))
                        {
                            throw new Exception("列/"" + p.HeaderText + "/"中存在非/"" + p.DataType + "/"类型数据！");
                        }
                    }
                    //属性长度检查
                    if (p.DataLength != 0 && p.DataLength != 5000)
                    {
                        if(!ValidateDataLength(v,p.DataLength))
                        {
                            throw new Exception("列/"" + p.HeaderText + "/"中存长度超过/"" + p.DataLength.ToString() + "/"的数据！");
                        }
                    }
                    sql += "'"+v.Replace("'", "''")+"',";
                }
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        //数据类型校验
        private bool ValidateDataType(string value,string type)
        {
            bool r=false;
            double t = 0;
            switch (type.ToLower())
            {
                case "number":
                    r = double.TryParse(value, out t);
                    break;
                case "string": r = true; 
                    break;
                default: break; ;
            }
            return r;
        }
        //数据长度校验
        private bool ValidateDataLength(string value, int length)
        {
            if (value.Length > length)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 得到查询值sql语句段（未配置列情况下使用且有别名）
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="headerIndex"></param>
        /// <param name="dataIndex"></param>
        /// <returns></returns>
        private string GetSqlFieldValueStringAccordingToAlias(AsposeCell asposeCell, int headerIndex, int dataIndex)//对于没有配置列的情况使用
        {
            string sql = "";
            foreach (string columnName in asposeCell.GetRangeNames(headerIndex - 1))
            {
                if(asposeCell.IsMerged(dataIndex - 1,asposeCell.GetColumnIndexByRangeName(columnName)))
                {
                    sql+="'"+asposeCell.GetMergedCellValue(dataIndex - 1, asposeCell.GetColumnIndexByRangeName(columnName)).Replace("'","''")+"',";
                }
                else
                {
                    sql += "'" + asposeCell.GetCellValue(dataIndex - 1, asposeCell.GetColumnIndexByRangeName(columnName)).Replace("'", "''") + "',";
                }
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        /// <summary>
        /// 得到查询值sql语句段（未配置列情况下使用且无别名,不管有没有排除字段）
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="headerIndex"></param>
        /// <param name="dataIndex"></param>
        /// <returns></returns>
        private string GetSqlFieldValueStringWithoutAlias(AsposeCell asposeCell,Entity entity, int headerIndex, int dataIndex)//对于没有配置列的情况使用
        {
            string sql = "";
            int column = 0;
            while (asposeCell.GetCellValue(headerIndex-1, column) != "")
            {
                sql += "'" + (asposeCell.IsMerged(dataIndex - 1, column) ? asposeCell.GetMergedCellValue(dataIndex - 1, column) : asposeCell.GetCellValue(dataIndex - 1, column)).Replace("'","''") + "',";
                column++;
            }
            sql = sql.TrimEnd(',');
            return sql;
        }
        /// <summary>
        /// 得到代码表的对应值
        /// </summary>
        /// <param name="asposeCell"></param>
        /// <param name="property"></param>
        /// <param name="headerIndex"></param>
        /// <param name="dataIndex"></param>
        /// <returns></returns>
        private string GetCodeTableValue(AsposeCell asposeCell,Property property,int headerIndex,int dataIndex)
        {
            string value=asposeCell.IsMerged(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, property.HeaderText))?asposeCell.GetMergedCellValue(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, property.HeaderText)):asposeCell.GetCellValue(dataIndex-1, GetColumnIndexByHeaderText(asposeCell, headerIndex, property.HeaderText)).Replace("'","''");
            StringBuilder sb = new StringBuilder("select distinct ");
            sb.Append(property.CodeTable.PrimaryKey);
            sb.Append(" from ");
            sb.Append(property.CodeTable.Name);
            sb.Append(" where ");
            sb.Append(property.CodeTable.ReferenceColumn);
            sb.Append("='");
            sb.Append(value);
            sb.Append("'");
            if (property.DataType != "" && property.DataType != "string")
            {
                if (!ValidateDataType(value, property.DataType))
                {
                    throw new Exception("列/"" + property.HeaderText + "/"中存在非/"" + property.DataType + "/"类型数据！");
                }
            }
            if (property.DataLength != 0 && property.DataLength != 5000)
            {
                if (!ValidateDataLength(value, property.DataLength))
                {
                    throw new Exception("列/"" + property.HeaderText + "/"中存长度超过/"" + property.DataLength.ToString() + "/"的数据！");
                }
            }
            if (dbHelper.ExecuteScalar(CommandType.Text, sb.ToString()) != null)
            {
                return dbHelper.ExecuteScalar(CommandType.Text, sb.ToString()).ToString();
            }
            else
            {
                throw new Exception("没有对应的代码表值！");
            }
        }
        //初始化，主要将excel文件和配置类对应关系存放到configs对象中，方便以后遍历
        private void InitConfig()
        {
            configs=new Dictionary<string,Config>();
            List<string> excelFullNames=new List<string>();
            if(MyFilleBase.DirectoryBeing(excelPath))//判断目录是否存在(注意：除了多套excel对应多套模板，还可能有一个模板对应多个excel的情况）
            {
                FileSearch.InitFileInfoList();
                List<string> excelConfigFileFullNames= FileSearch.GetFileInfo(".xml", ConfigHelper.Instance().ExcelPath, true, true);//在目录中查找所有名称中包含".xml"的文件
                if (excelConfigFileFullNames.Count == 1)//说明是一个excel对应一个xml配置文件的情况
                {
                    AddConfigsByXmlFullNameHasNothingToExcelname(excelConfigFileFullNames[0]);
                }
                else if(excelConfigFileFullNames.Count>1)//说明目录中有多个xml文件，对应多个excel
                {
                    foreach (string excelConfigFileFullName in excelConfigFileFullNames)
                    {
                        AddConfigsByXmlFullName(excelConfigFileFullName);
                    }
                }
                else
                {
                    throw new Exception("所指定目录不包含任何XLM模板，请重新指定！");
                }
            }
            else//说明指定的不是目录而是excel文件路径
            {
                AddConfigByExcelFullName(excelPath);
            }
        }
        //根据Excel全路径构造路径和配置类对应关系（主要用于指导Excel全路径的情况）
        private void AddConfigByExcelFullName(string excelFullName)
        {
            string excelConfigFileFullName = MyFilleBase.GetDirectoryByFullName(excelFullName) + "//" + MyFilleBase.GetFileNameWithoutExtension(excelFullName) + ".xml";
            Config config=null;
            if (MyFilleBase.FileBeing(excelConfigFileFullName))
            {
                config = new Config(excelConfigFileFullName);//创建配置（Config）对象
                configs.Add(excelFullName, config);
            }
            else
            {
                throw new Exception("所指定文件没有对应的配置文件，请重新指定！");
            }
        }
        //根据XML文件全路径构造路径和配置类对应关系(得到一个xml文件对应的所有excel然后构造config对象存放到configs中)
        private void AddConfigsByXmlFullName(string xmlFullName)
        {
            string excelDirectory = MyFilleBase.GetDirectoryByFullName(xmlFullName);//根据路径取得对应的目录
            Config config=null;
            FileSearch.InitFileInfoList();
            List<string> excelFullNames = FileSearch.GetFileInfo(MyFilleBase.GetFileNameWithoutExtension(xmlFullName), excelDirectory, true, true);//根据xml的名称搜索包含此名称的文件
            if (excelFullNames.Count >= 1)
            {
                foreach (string excelFullName in excelFullNames)
                {
                    if (excelFullNames.IndexOf(".xls") != -1)//必须是excel文件(排除xml文件)
                    {
                        config = new Config(xmlFullName);
                        configs.Add(excelFullName, config);
                    }
                }
            }
            else
            {
                throw new Exception("所指定模板不包含对应的Excel文件，请重新指定！");
            }
        }
        //根据XML文件全路径构造路径和配置类对应关系（此种情况由于只有一个xml，必然对应一个或多个excel文件，所以只需要查找excel文件即可）
        private void AddConfigsByXmlFullNameHasNothingToExcelname(string xmlFullName)
        {
            Config config = null;
            string excelDirectory=MyFilleBase.GetDirectoryByFullName(xmlFullName);
            FileSearch.InitFileInfoList();
            List<string> excelFullNames = FileSearch.GetFileInfo(".xls", excelDirectory, true, true);
            if (excelFullNames.Count >= 1)
            {
                foreach (string excelFullName in excelFullNames)
                {
                    config = new Config(xmlFullName);
                    configs.Add(excelFullName, config);
                }
            }
            else
            {
                throw new Exception("所指定模板不包含对应的Excel文件，请重新指定！");
            }
        }
    }
}

注意：程序中用到了Cmj.dll（自定义的一个类库）中的几个类，具体说明如下（如果需要具体的代码可以发Email给我，[e-mail] ）：

SqlHelper：数据库操作类，使用时在配置文件的ConnectionStrings中配置name为"DBCon"的连接串，指明ProviderName即可，如果不使用配置可以直接在构造函数中传递这两个参数。

MyXML：对于XML文件操作的封装了，用于XML文件操作。

MyFileBase：对文件操作的封装。

FileSearch：对文件查找的封装，可以按照关键字查找文件。

六、一点补充

为了更加容易理解，我对程序中的一些约定和处理做少许补充。

Excel类中有参构造函数两个参数分别是excel路径（也可以是目录）以及是否启用事务的bool型变量。如果用户使用无参构造函数的话，就必须在应用程序配置文件的appSettings配置节点配置中配置"ExcelPath"和"UseTransaction"两个节点。由于对数据库的操作需要访问应用程序的配置文件，因此需要配置connectionStrings节点。

一般的导入按照上面的配置就可以完成了。为了方便使用此类还提供了其他导入方式。假如觉得列配置较麻烦的，觉得没有必要配置那么多列的话，可以考虑下面几种方式。

ⅰ 配置文件中如果没有Column配置，可以通过配置单元格的别名，来指示每一个列对应的表字段。

ⅱ 如果配置文件中没有Column配置，而又不希望指定单元格别名，但是Excel中的列和表中的列又不是一一对应的（很可能有些列数据库表中有，而Excel中没有），此时如果Excel中列的顺序和表中顺序一致，你就可以通过在配置文件中设置Table的ExcludedColumns来将这些列排除（多个需要排除的列中间用"，"分割）。

ⅲ 如果我的Excel中的列和数据库表中完全一致且顺序一样，那么你出来配置文件中配置Table属性外就不需要任何额外的配置了。

另外，如果需要在导入时检查是否有默写列唯一的情况的情况（例如ProductName我不希望有重复），对于重复的先删除再倒入，此时可以再此列上设置IsPrimaryKey为true，然后在Table的属性中配置DeleteRepeat为true就可以了；如果所有的导入过程中你需要使用事务机制，可以在应用程序配置appSettings 配置节点中指定useTransaction为true（注意先要保证事务服务是启动的）；程序支持合并行的导入。

关于配置文件和Excel文件的关系，是这样约定的，多数情况下ExcelPath的配置为目录（当然可以是一个Excel文件路径，此时就只导入该Excel文件），对于此种情形可能出现下列情况。

ⅰ 目录中只有一个配置文件，而有一个或多个Excel。这种情况下程序认为此配置文件对应所有Excel文件，将会使用此配置将所有Excel导入。

ⅱ 目录中有多个配置文件，并且有多个Excel文件。此时程序户根据配置文件的名称自动匹配Excel文件，匹配的规则就是它对应的Excle文件的名称中要出现配置文件的名称。

七、简单的测试

下面我们简单的测试一下我们的类库，应该说使用起来十分简单。

ⅰ 在使用之前当然要有一个需要导入的Excel

ⅱ 根据Excel编写xml文件

<?xml version="1.0" encoding="utf-8" ?>
<Config EndTag="RowBlank" HeaderIndex="1" DataIndex="2">
  <Table Name="Products" >
    <Column ColumnName="SupplierID" HeaderText="供货商" DefaultValue="">
      <CodeTalbe Name="Suppliers" PrimaryKey="SupplierID"  ReferenceColumn="CompanyName"></CodeTalbe>
    </Column>
    <Column ColumnName="ProductName" HeaderText="商品名称" DefaultValue="" />
    <Column ColumnName="CategoryID" HeaderText="商品种类" DefaultValue="">
      <CodeTalbe Name="Categories" PrimaryKey="CategoryID"  ReferenceColumn="CategoryName" ></CodeTalbe>
    </Column>
    <Column ColumnName="QuantityPerUnit" HeaderText="规格" DefaultValue=""  />
    <Column ColumnName="UnitPrice" HeaderText="单价" DefaultValue="" />
    <Column ColumnName="UnitsInStock" HeaderText="库存" DefaultValue="" />
    <Column ColumnName="Discontinued" HeaderText="是否停产" DefaultValue="" />
  </Table>
</Config>

ⅲ 将excel文件和对应xml文件放到F:/Cmj.DataExchange/wfTest/excel

ⅳ 建立一个项目，添加Cmj.DataExchange.dll引用

ⅴ 在配置文件中配置数据库连接以及Excel目录等

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="ExcelPath" value="F:/Cmj.DataExchange/wfTest/excel"/> <!--Excel文件所在路径或者其根目录（此时会将其下所有excel全部倒入）-->
    <add key="UseTransaction" value="true"/>
  </appSettings>
  <connectionStrings>
    <add name="DbConStr" connectionString="Data Source=.;Database=Northwind;Integrated Security=SSPI" providerName="System.Data.SqlClient"/>
  </connectionStrings>
</configuration>

ⅵ 接着确保Distributed Transaction Coordinator服务是启动的（因为程序中用的是.Net2.0的事务，当然你也可以使用.Net1.0事务，此时就无需启动此服务了）。

ⅶ 最后添加下面两句代码就可以完成整个导入了。

Excel ex = new Excel();
ex.Import();

下面是导入前后数据库Northwind中Products表中的数据（已经成功导入）

导入之前

导入之后

八、总结

对于一般的Excel导入情况程序基本上都能够解决，但是开发过程中难免遇到更复杂的情况，此时就需要更多的考虑和更复杂多样的设计，这种情况有机会我们再一看探讨。由于代码相对比较长阅读多少有些不便，这里提供源代码和示例下载 ，需要的朋友可以看一下。