C#连接层的数据访问类（简单版）

using System;
using System.Configuration;

namespace XPSoft.BaseLibrary.DataAccess
{
    /// <summary>
    /// 数据访问对象的静态工厂类，用于创建不同类型的数据访问对象。
    /// </summary>
    public static class DataAccessFactory
    {
        /// <summary>
        /// 通过数据访问类型去实例化一个数据访问对象。
        /// </summary>
        /// <param name="dataAccessType">数据访问类型枚举。</param>
        /// <returns>数据访问对象。</returns>
        public static IDataAccess InstanceDataAccess(DataAccessType dataAccessType)
        {
            //  声明一个数据访问对象，根据枚举参数选择实例化哪种类型。
            IDataAccess dataAccess = null;
            string provideName = ConfigurationManager.ConnectionStrings["SqlServer"].ProviderName;
            string connectionString = ConfigurationManager.ConnectionStrings["SqlServer"].ConnectionString;
            switch (dataAccessType)
            { 
                //  创建SqlServer数据访问类。
                case DataAccessType.SqlServer:
                    dataAccess = new SqlServerDataAccess(ConfigurationManager.ConnectionStrings["SqlServer"].ToString());
                    break;
            }
            if (dataAccess == null) { throw new ArgumentNullException("通过传入的枚举值，未能找到合适的数据访问类。"); }
            return dataAccess;
        }
    }
}

using System;

namespace XPSoft.BaseLibrary.DataAccess
{
    /// <summary>
    /// 数据访问类型枚举。
    /// </summary>
    public enum DataAccessType : byte
    {
        Oracle = 0,     //  Oracle数据库。
        SqlServer = 1,  //  SqlServer数据库。
        MySql = 2,      //  MySql数据库。
        Oledb = 3       //  其他数据库。
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Xml;

namespace XPSoft.BaseLibrary.DataAccess
{
    public interface IDataAccess
    {
        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQuery(string commandText);

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQuery(DbCommand command);

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQuery(IList<string> commandTexts);

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commands">要执行的DbCommand接口集合。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQuery(IList<DbCommand> commands);

        /// <summary>
        /// 执行不返回数据集的存储过程。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQueryByStoredProcedure(string storedProcedureName);

        /// <summary>
        /// 执行不返回数据集的存储过程。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <returns>受影响的行数。</returns>
        int ExecuteNonQueryByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);

        /// <summary>
        /// 执行Sql操作，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <returns>数据集的第一行第一列。</returns>
        object ExecuteScalar(string commandText);

        /// <summary>
        /// 执行Sql操作，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <returns>数据集的第一行第一列。</returns>
        object ExecuteScalar(DbCommand command);

        /// <summary>
        /// 执行存储过程，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <returns>数据集的第一行第一列。</returns>
        object ExecuteScalarByStoredProcedure(string storedProcedureName);

        /// <summary>
        /// 执行存储过程，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <returns>数据集的第一行第一列。</returns>
        object ExecuteScalarByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);

        /// <summary>
        /// 执行Sql操作，返回DataSet数据集。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSet(string commandText);

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSet(DbCommand command);

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSet(IList<string> commandTexts, IList<string> tableNames);

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="commandTexts">要执行的DbCommand接口集合。</param>
        /// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSet(IList<DbCommand> commands, IList<string> tableNames);

        /// <summary>
        /// 执行存储过程，返回DataSet数据集。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName);

        /// <summary>
        /// 执行存储过程，返回DataSet数据集。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <returns>DataSet数据集。</returns>
        DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);

        /// <summary>
        /// 执行Sql语句，返回XmlDocument对象。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <returns>XmlDocument对象。</returns>
        XmlDocument ExecuteDataXml(string commandText);

        /// <summary>
        /// 执行Sql操作，返回XmlDocument对象。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <returns>XmlDocument对象。</returns>
        XmlDocument ExecuteDataXml(DbCommand command);

        /// <summary>
        /// 执行Sql操作，返回XmlDocument对象。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <param name="tableNames">XmlDocument对象中Element属性的名称集合。</param>
        /// <returns>XmlDocument对象。</returns>
        XmlDocument ExecuteDataXml(IList<string> commandTexts, IList<string> tableNames);

        /// <summary>
        /// 执行存储过程，返回XmlDocument对象。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <returns>XmlDocument对象。</returns>
        XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName);

        /// <summary>
        /// 执行存储过程，返回XmlDocument对象。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <returns>XmlDocument对象。</returns>
        XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Xml;

namespace XPSoft.BaseLibrary.DataAccess
{
    public class SqlServerDataAccess : IDataAccess
    {
        //  数据库连接对象。
        private static SqlConnection connection = null;

        /// <summary>
        /// 构造函数。
        /// </summary>
        public SqlServerDataAccess() { }

        /// <summary>
        /// 构造函数。
        /// </summary>
        /// <param name="connectionString">数据库连接字符串。</param>
        public SqlServerDataAccess(string connectionString) 
        {
            if (connection == null) { 
                //  通过字符串实例化SqlConnection对象。
                connection = new SqlConnection(connectionString);
            }
        }

        #region 私有方法

        /// <summary>
        /// 打开数据库连接对象。
        /// </summary>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        private void OpenConnection()
        {
            //  如果数据连接为关闭状态，那么将打开连接。
            //  否则将抛出异常。
            if (connection.State == ConnectionState.Closed)
            {
                try { connection.Open(); }
                catch (SqlException sqlEx) { throw sqlEx; }
                catch (InvalidOperationException iopEx) { throw iopEx; }
            }
        }

        /// <summary>
        /// 关闭数据库连接对象。
        /// </summary>
        /// <exception cref="SqlException"></exception>
        private void CloseConnection()
        {
            //  如果数据连接不为关闭状态，那么将关闭连接。
            //  否则将抛出异常。
            if (connection.State != ConnectionState.Closed)
            {
                try { connection.Close(); }
                catch (SqlException sqlEx) { throw sqlEx; }
            }
        }

        /// <summary>
        /// 将DataSet中的列映射成XML特性。
        /// </summary>
        /// <param name="ds">DataSet对象。</param>
        private XmlDocument ConvertDataSetToXmlDocument(DataSet ds)
        {
            foreach (DataTable dt in ds.Tables)
            {
                foreach (DataColumn dc in dt.Columns)
                {
                    dc.ColumnMapping = MappingType.Attribute;
                }
            }
            XmlDocument xmlDom = new XmlDocument();
            xmlDom.LoadXml(ds.GetXml());
            return xmlDom;
        }

        #endregion

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQuery(string commandText) 
        {
            //  如果要执行的Sql语句为空，将抛出ArgumentException异常。
            if (string.IsNullOrWhiteSpace(commandText)) 
            { throw new ArgumentException("要执行的Sql语句不能为空。"); }
            try
            {
                //  实例化一个SqlCommand对象，并指定要执行的Sql语句。
                using (DbCommand command = new SqlCommand(commandText, connection))
                {
                    //  打开数据库连接对象。
                    this.OpenConnection();
                    //  执行操作并返回受影响的行数。
                    int count = command.ExecuteNonQuery();
                    return count;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx) { throw iopEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQuery(DbCommand command)
        {
            try
            {
                //  打开数据库连接对象。
                command.Connection = connection;
                this.OpenConnection();
                //  执行操作并返回受影响的行数。
                int count = command.ExecuteNonQuery();
                return count;
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx) { throw iopEx; }
            finally 
            {
                command.Dispose();
                this.CloseConnection(); 
            }
        }

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <exception cref="ArgumentNullException、SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQuery(IList<string> commandTexts)
        {
            if (commandTexts.Count <= 0)
            { throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
            //  Sql事务。
            SqlTransaction transaction = null;
            try
            {
                //  实例化一个SqlCommand对象，并指定要执行的Sql语句。
                using (DbCommand command = new SqlCommand())
                {
                    int count = 0;
                    //  打开数据库连接对象。
                    this.OpenConnection();
                    command.Connection = connection;
                    //  开始事务。
                    transaction = connection.BeginTransaction();
                    command.Transaction = transaction;
                    foreach (string commandText in commandTexts)
                    {
                        //  执行操作。
                        command.CommandText = commandText;
                        count += command.ExecuteNonQuery();
                    }
                    //  提交事务。
                    transaction.Commit();
                    //  返回受影响的行数。
                    return count;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx) 
            {
                //  回滚事务。
                transaction.Rollback();
                throw iopEx; 
            }
            finally 
            {
                transaction.Dispose();
                this.CloseConnection(); 
            }
        }

        /// <summary>
        /// 执行不返回数据集的Sql操作。
        /// </summary>
        /// <param name="commands">要执行的DbCommand接口集合。</param>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQuery(IList<DbCommand> commands)
        {
            //  受影响的行数。
            int count = 0;
            //  数据库事务对象。
            SqlTransaction transaction = null;
            try
            {
                //  打开数据库连接对象。
                this.OpenConnection();
                //  设置数据库事务对象。
                transaction = connection.BeginTransaction();
                foreach (DbCommand command in commands)
                {
                    //  执行操作并返回受影响的行数。
                    command.Connection = connection;
                    command.Transaction = transaction;
                    count += command.ExecuteNonQuery();
                    command.Dispose();
                }
                //  提交事务。
                transaction.Commit();
                //  返回影响的行数。
                return count;
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx)
            {
                //  回滚事务。
                transaction.Rollback();
                throw iopEx;
            }
            finally
            {
                transaction.Dispose();
                this.CloseConnection();
            }
        }

        /// <summary>
        /// 执行不返回数据集的存储过程。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQueryByStoredProcedure(string storedProcedureName)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName)) 
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    //  执行操作。
                    int count = command.ExecuteNonQuery();
                    //  返回受影响的行数。
                    return count;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行不返回数据集的存储过程。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>受影响的行数。</returns>
        public int ExecuteNonQueryByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    //  添加存储过程参数。
                    foreach (DbParameter parameter in parameters)
                    {
                        command.Parameters.Add(parameter);
                    }
                    //  执行操作。
                    int count = command.ExecuteNonQuery();
                    //  返回受影响的行数。
                    return count;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql操作，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>数据集的第一行第一列。</returns>
        public object ExecuteScalar(string commandText)
        {
            //  如果要执行的Sql语句为空，将抛出ArgumentException异常。
            if (string.IsNullOrWhiteSpace(commandText)) 
            { throw new ArgumentException("要执行的Sql语句不能为空。"); }
            try
            {
                //  实例化一个SqlCommand对象，并指定要执行的Sql语句。
                using (DbCommand command = new SqlCommand(commandText, connection))
                {
                    //  打开数据库连接对象。
                    this.OpenConnection();
                    //  返回数据集的第一行第一列。
                    object result = command.ExecuteScalar();
                    return result;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx) { throw iopEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql操作，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        /// <returns>数据集的第一行第一列。</returns>
        public object ExecuteScalar(DbCommand command)
        {
            try
            {
                //  打开数据库连接对象。
                command.Connection = connection;
                this.OpenConnection();
                //  返回数据集的第一行第一列。
                object result = command.ExecuteScalar();
                return result;
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException iopEx) { throw iopEx; }
            finally
            {
                command.Dispose();
                this.CloseConnection();
            }
        }

        /// <summary>
        /// 执行存储过程，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>数据集的第一行第一列。</returns>
        public object ExecuteScalarByStoredProcedure(string storedProcedureName) 
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接对象。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    //  返回数据集的第一行第一列。
                    object result = command.ExecuteScalar();
                    return result;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行存储过程，返回数据集的第一行第一列。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>数据集的第一行第一列。</returns>
        public object ExecuteScalarByStoredProcedure(string storedProcedureName, params DbParameter[] parameters) 
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接对象。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    //  添加存储过程参数。
                    foreach (DbParameter parameter in parameters)
                    {
                        command.Parameters.Add(parameter);
                    }
                    //  返回数据集的第一行第一列。
                    object result = command.ExecuteScalar();
                    return result;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql操作，返回DataSet数据集。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSet(string commandText)
        {
            if (string.IsNullOrWhiteSpace(commandText))
            { throw new ArgumentNullException("commandText", "要执行的Sql语句不能为空。"); }
            try
            {
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand(commandText))
                {
                    //  创建数据库适配器。
                    using (DbDataAdapter adapter = new SqlDataAdapter())
                    {             
                        adapter.SelectCommand = command;
                        //  打开数据库连接对象。
                        command.Connection = connection;
                        OpenConnection();
                        //  创建数据集。
                        DataSet dataSet = new DataSet();
                        //  填充数据集。
                        adapter.Fill(dataSet);
                        //  返回数据集。
                        return dataSet;
                    }
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSet(DbCommand command)
        {
            try
            {
                //  创建数据库适配器。
                using (DbDataAdapter adapter = new SqlDataAdapter())
                {
                    adapter.SelectCommand = command;
                    //  打开数据库连接对象。
                    command.Connection = connection;
                    OpenConnection();
                    //  创建数据集。
                    DataSet dataSet = new DataSet();
                    //  填充数据集。
                    adapter.Fill(dataSet);
                    //  返回数据集。
                    return dataSet;
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
        /// <exception cref="ArgumentNullException、SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSet(IList<string> commandTexts, IList<string> tableNames)
        { 
            try
            {
                if (commandTexts.Count <= 0)
                { throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
                if (commandTexts.Count != tableNames.Count)
                { throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
                //  打开数据库连接。
                OpenConnection();
                //  创建数据集。
                DataSet dataSet = new DataSet();
                for (int i = 0; i < commandTexts.Count; i++)
                {
                    //  创建数据库命令对象。
                    using (DbCommand command = new SqlCommand(commandTexts[i]))
                    {
                        command.Connection = connection;
                        //  创建数据库适配器。
                        using (DbDataAdapter adapter = new SqlDataAdapter())
                        {
                            //  创建数据表。
                            DataTable dataTable = new DataTable();
                            //  设置数据表的名称。
                            dataTable.TableName = tableNames[i];
                            //  填充数据表。
                            adapter.SelectCommand = command;
                            adapter.Fill(dataTable);
                            //  将数据表添加到数据集。
                            dataSet.Tables.Add(dataTable);
                            //  释放数据适配器。
                            adapter.Dispose();
                        }
                    }
                }
                return dataSet;
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql语句，返回DataSet数据集。
        /// </summary>
        /// <param name="commandTexts">要执行的DbCommand接口集合。</param>
        /// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSet(IList<DbCommand> commands, IList<string> tableNames)
        {
            try
            {
                if (commands.Count != tableNames.Count)
                { throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
                //  打开数据库连接。
                OpenConnection();
                //  创建数据集。
                DataSet dataSet = new DataSet();
                for (int i = 0; i < commands.Count; i++)
                {
                    commands[i].Connection = connection;
                    //  创建数据库适配器。
                    using (DbDataAdapter adapter = new SqlDataAdapter())
                    {
                        //  创建数据表。
                        DataTable dataTable = new DataTable();
                        //  设置数据表的名称。
                        dataTable.TableName = tableNames[i];
                        //  填充数据表。
                        adapter.SelectCommand = commands[i];
                        adapter.Fill(dataTable);
                        //  将数据表添加到数据集。
                        dataSet.Tables.Add(dataTable);
                        //  释放数据适配器。
                        adapter.Dispose();
                    }
                    commands[i].Dispose();
                }
                return dataSet;
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行存储过程，返回DataSet数据集。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接对象。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    using (DbDataAdapter adapter = new SqlDataAdapter())
                    {
                        //  创建数据集。
                        DataSet dataSet = new DataSet();
                        //  填充数据集。
                        adapter.SelectCommand = command;
                        adapter.Fill(dataSet);
                        //  释放数据适配器。
                        adapter.Dispose();
                        //  释放数据库命令对象。
                        command.Dispose();
                        //  返回数据集。
                        return dataSet;
                    }
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行存储过程，返回DataSet数据集。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>DataSet数据集。</returns>
        public DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  打开数据库连接对象。
                OpenConnection();
                //  创建数据库命令对象。
                using (DbCommand command = new SqlCommand())
                {
                    command.Connection = connection;
                    command.CommandText = storedProcedureName;
                    command.CommandType = CommandType.StoredProcedure;
                    foreach (SqlParameter parameter in parameters)
                    {
                        command.Parameters.Add(parameter);
                    }
                    using (DbDataAdapter adapter = new SqlDataAdapter())
                    {
                        //  创建数据集。
                        DataSet dataSet = new DataSet();
                        //  填充数据集。
                        adapter.SelectCommand = command;
                        adapter.Fill(dataSet);
                        //  释放数据适配器。
                        adapter.Dispose();
                        //  释放数据库命令对象。
                        command.Dispose();
                        //  返回数据集。
                        return dataSet;
                    }
                }
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
            finally { this.CloseConnection(); }
        }

        /// <summary>
        /// 执行Sql语句，返回XmlDocument对象。
        /// </summary>
        /// <param name="commandText">要执行的Sql语句。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>XmlDocument对象。</returns>
        public XmlDocument ExecuteDataXml(string commandText) 
        {
            if (string.IsNullOrWhiteSpace(commandText))
            { throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
            try
            {
                //  格式化DataSet对象。
                DataSet ds = this.ExecuteDataSet(commandText);
                //  返回XmlDocument对象。
                return ConvertDataSetToXmlDocument(ds);
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
        }

        /// <summary>
        /// 执行Sql操作，返回XmlDocument对象。
        /// </summary>
        /// <param name="command">要执行的数据库命令对象。</param>
        /// <exception cref="SqlException、InvalidOperationException"></exception>
        /// <returns>XmlDocument对象。</returns>
        public XmlDocument ExecuteDataXml(DbCommand command)
        {
            try
            {
                //  格式化DataSet对象。
                DataSet ds = this.ExecuteDataSet(command);
                //  返回XmlDocument对象。
                return ConvertDataSetToXmlDocument(ds);
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
        }

        /// <summary>
        /// 执行Sql操作，返回XmlDocument对象。
        /// </summary>
        /// <param name="commandTexts">要执行的Sql语句集合。</param>
        /// <param name="tableNames">XmlDocument对象中Element属性的名称集合。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>XmlDocument对象。</returns>
        public XmlDocument ExecuteDataXml(IList<string> commandTexts, IList<string> tableNames)
        {
            if (commandTexts.Count <= 0)
            { throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
            if (commandTexts.Count != tableNames.Count)
            { throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
            try
            {
                //  格式化DataSet对象。
                DataSet ds = this.ExecuteDataSet(commandTexts, tableNames);
                //  返回XmlDocument对象。
                return ConvertDataSetToXmlDocument(ds);
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
        }

        /// <summary>
        /// 执行存储过程，返回XmlDocument对象。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>XmlDocument对象。</returns>
        public XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  格式化DataSet对象。
                DataSet ds = this.ExecuteDataSetByStoredProcedure(storedProcedureName);
                //  返回XmlDocument对象。
                return ConvertDataSetToXmlDocument(ds);
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
        }

        /// <summary>
        /// 执行存储过程，返回XmlDocument对象。
        /// </summary>
        /// <param name="storedProcedureName">要执行的存储过程名称。</param>
        /// <param name="parameters">存储过程的参数。</param>
        /// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
        /// <returns>XmlDocument对象。</returns>
        public XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
        {
            if (string.IsNullOrWhiteSpace(storedProcedureName))
            { throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
            try
            {
                //  格式化DataSet对象。
                DataSet ds = this.ExecuteDataSetByStoredProcedure(storedProcedureName, parameters);
                //  返回XmlDocument对象。
                return ConvertDataSetToXmlDocument(ds);
            }
            catch (SqlException sqlEx) { throw sqlEx; }
            catch (InvalidOperationException ivoEx) { throw ivoEx; }
        }
    }
}