.NET下向Oralce 10g表批量导入数据

.Net2.0提供了SqlBulkCopy 类。使用 SqlBulkCopy 类向 SQL Server 表写入数据，数据源不限于 SQL Server，可以使用任何数据源，只要数据可加载到DataTable实例或可使用IDataReader实例读取数据。Oracle 11g同样提供了类似的做法。在Oracle.DataAccess.dll（2.112.1.0）中，oracle提供了OralceBulkCopy类，实现了向Oracle表写入数据。

但是现阶段，很多项目还在使用Oracle 10g。在Oracle 10g下并不能使用这一新特性。（本人已经试过加载Oralce11g中的Oracle.DataAccess.dll，但在没安装Oracle 11g客户端的情况下，仍然无法正常使用）本人就试着简单写了一个简单的类似于SqlBulkCopy的类，以便大家使用。

using System;
using System.Collections.Generic;
using System.Data;
using System.Text;
using System.IO;
using System.Diagnostics;
using Oracle.DataAccess.Client;

namespace SK.Common
{
    /// <summary>
/// Function：使您可以用其他源的数据有效批量加载 Oracle 表
/// Author  ：shike
/// CreationDate：2011-01-17
/// </summary>
    public class OracleBulkCopy : IDisposable
    {
        #region Variables and Properties
        /// <summary>
/// 在每次处理完 BatchSize 属性指定的行数时发生
/// </summary>
        public event OracleRowsCopiedEventHandler OracleRowsCopied;

        /// <summary>
/// 数据源DataTable与数据库 字段的映射集合，key：目标表字段名（英文名），value：源表字段名（中文名）
/// </summary>
        private Dictionary<string, string> _columnMappings;
        /// <summary>
/// 数据源DataTable与数据库 字段的映射集合，key：目标表字段名（英文名），value：源表字段名（中文名）
/// </summary>
        public Dictionary<string, string> ColumnMappings
        {
            get { return _columnMappings; }
            set { _columnMappings = value; }
        }

        /// <summary>
/// 每一批次中的行数。在每一批次结束时，将该批次中的行发送到服务
/// </summary>
        private int _batchSize;
        /// <summary>
/// 每一批次中的行数。在每一批次结束时，将该批次中的行发送到服务
/// </summary>
        public int BatchSize
        {
            get { return _batchSize; }
            set { _batchSize = value; }
        }

        /// <summary>
/// 服务器上目标表的名称
/// </summary>
        private string _destinationTableName;
        /// <summary>
/// 服务器上目标表的名称
/// </summary>
        public string DestinationTableName
        {
            get { return _destinationTableName; }
            set { _destinationTableName = value; }
        }

        /// <summary>
/// 数据库连接字符串
/// </summary>
        private string _connectionString;

        /// <summary>
/// 数据库连接
/// </summary>
        private OracleConnection _oracleConn;

        /// <summary>
/// 数据库执行的SQL语句或存储过程
/// </summary>
        private OracleCommand _oracleCommand;
        #endregion

        /// <summary>
/// 基于提供的 connectionString 初始化 OracleBulkCopy 类的新实例
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
        public OracleBulkCopy(string connectionString)
        {
            this._batchSize = 0;
            this._destinationTableName = string.Empty;
            this._connectionString = connectionString;

            this._oracleConn = new OracleConnection(this._connectionString);
            this._oracleCommand = new OracleCommand();
            this._oracleCommand.Connection = this._oracleConn;
        }

        /// <summary>
/// 将所提供的 System.Data.DataTable 中的所有行复制到 DestinationTableName 属性指定的目标表中
/// </summary>
/// <param name="dt">提供的 System.Data.DataTable</param>
        public void WriteToServer(DataTable dt)
        {
            try
            {
                //打开连接
                this.open();
                //计算出一共需要提交的批次的数量
                int mCount = (int)(dt.Rows.Count / this._batchSize) + 1;

                //循环分批次提交
                for (int i = 0; i < mCount; i++)
                {
                    //清空参数集合
                    this._oracleCommand.Parameters.Clear();
                    StringBuilder fStr = new StringBuilder();//字段
                    StringBuilder pStr = new StringBuilder();//参数
                    if (i != mCount - 1)//非最后一批
                    {
                        this._oracleCommand.ArrayBindCount = this._batchSize;

                        foreach (KeyValuePair<string, string> kv in this._columnMappings)
                        {
                            //拼字段
                            fStr.Append(kv.Key);
                            fStr.Append(',');
                            pStr.Append(":" + kv.Key);
                            pStr.Append(',');

                            //生成参数，参数是数字组的形式
                            OracleParameter param = new OracleParameter(kv.Key, OracleDbType.NVarchar2);
                            param.Direction = ParameterDirection.Input;
                            string[] paramValue = new string[this._batchSize];
                            for (int j = i * this._batchSize; j < (i + 1) * this._batchSize; j++)
                            {
                                string v = dt.Rows[j][kv.Value].ToString();
                                paramValue[j % this._batchSize] = v;
                            }

                            param.Value = paramValue;
                            this._oracleCommand.Parameters.Add(param);
                        }
                        this._oracleCommand.CommandText =
                            string.Format("insert into {0}({1}) values({2})",
                                this._destinationTableName,
                                fStr.ToString().TrimEnd(','),
                                pStr.ToString().TrimEnd(','));
                        this._oracleCommand.ExecuteNonQuery();

                        OracleRowsCopiedEventArgs arg1 = new OracleRowsCopiedEventArgs(true, false);
                        this.OracleRowsCopied(this, arg1);
                    }//最后一批
                    else
                    {
                        this._oracleCommand.ArrayBindCount = dt.Rows.Count - (i * this._batchSize);

                        foreach (KeyValuePair<string, string> kv in this._columnMappings)
                        {
                            //拼字段
                            fStr.Append(kv.Key);
                            fStr.Append(',');
                            pStr.Append(":" + kv.Key);
                            pStr.Append(',');

                            //生成参数，参数是数字组的形式
                            OracleParameter param = new OracleParameter(kv.Key, OracleDbType.NVarchar2);
                            param.Direction = ParameterDirection.Input;
                            string[] paramValue = new string[dt.Rows.Count - (i * this._batchSize)];
                            for (int j = i * this._batchSize; j < dt.Rows.Count; j++)
                            {
                                string v = dt.Rows[j][kv.Value].ToString();
                                paramValue[j % this._batchSize] = v;
                            }

                            param.Value = paramValue;
                            this._oracleCommand.Parameters.Add(param);
                        }
                        this._oracleCommand.CommandText =
                            string.Format("insert into {0}({1}) values({2})",
                                this._destinationTableName,
                                fStr.ToString().TrimEnd(','),
                                pStr.ToString().TrimEnd(','));
                        this._oracleCommand.ExecuteNonQuery();

                        OracleRowsCopiedEventArgs arg3 = new OracleRowsCopiedEventArgs(true, true);
                        this.OracleRowsCopied(this, arg3);
                    }
                }
            }
            catch (Exception ex)
            {
                OracleRowsCopiedEventArgs arg2 = new OracleRowsCopiedEventArgs(false, false);
                this.OracleRowsCopied(this, arg2);
                SystemLog.Error("导入数据失败!", e);
            }
            finally
            {
                this.close();
            }
        }

        #region IDisposable 成员

        public void Dispose()
        {
            if (this._oracleCommand != null)
                this._oracleCommand.Dispose();
            if (this._oracleConn != null)
                this._oracleConn.Dispose();
        }

        #endregion

        #region privateMethod
        /// <summary>
/// 打开数据库连接
/// </summary>
        private void open()
        {
            if (this._oracleConn.State == ConnectionState.Closed)
            {
                try
                {
                    this._oracleConn.Open();
                }
                catch (Exception e)
                {
                    SystemLog.Error("数据库连接失败!", e);
                }
            }
        }

        /// <summary>
/// 关闭数据库连接
/// </summary>
        private void close()
        {
            try
            {
                if (this._oracleConn.State == ConnectionState.Open)
                {
                    this._oracleConn.Close();
                }
            }
            catch (Exception ex)
            {
                SystemLog.Error("关闭数据库连接失败!", ex);
            }
        }
        #endregion
    }

    /// <summary>
/// Function：OracleBulkCopy 的 OracleBulkCopy.OracleRowsCopied事件的方法
/// Author  ：shike
/// CreationDate：2011-01-17
/// </summary>
/// <param name="sender">事件源</param>
/// <param name="e"></param>
    public delegate void OracleRowsCopiedEventHandler(object sender, OracleRowsCopiedEventArgs e);

    /// <summary>
/// Function：表示传递给OracleRowsCopiedEventHandler 的参数集
/// Author  ：shike
/// CreationDate：2011-01-17
/// </summary>
    public class OracleRowsCopiedEventArgs : EventArgs
    {
        /// <summary>
/// 是否全部提交成功
/// </summary>
        public bool IsAllSucceed { get; set; }
        /// <summary>
/// 是否单批提交成功
/// </summary>
        public bool IsSucceed { get; set; }

        public OracleRowsCopiedEventArgs()
            : this(false, false)
        { }

        public OracleRowsCopiedEventArgs(bool isSucceed, bool isAllSucceed)
        {
            this.IsSucceed = isSucceed;
            this.IsAllSucceed = isAllSucceed;
        }
    }
}