自己写的一个数据访问类

/**/ /*
 * 名称:        DataAccessFactory.cs
 * 命名空间:    Mouse.Tools.Data
 * 类:            DataAccessFactory
 * 版本:        1.0
 * 说明:
 *     数据访问工厂类,用于产生数据访问类实例
 * 作者:        幸福的耗子
 * 创建日期:    2007.01.29
 * 修改日期:    2007.01.30
 * */
using  System;
using  Mouse.Tools.Data.DataAccessClass;

namespace  Mouse.Tools.Data
... {
    /**//// <summary>
    /// 数据访问工厂类
    /// </summary>
    public sealed class DataAccessFactory
    ...{
        /**//// <summary>
        /// 创建DataAccess对象
        /// </summary>
        /// <param name="databaseType">要创建DataAccess对象的类型</param>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">默认数据库</param>
        /// <param name="tableName">默认表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        /// <returns>返回创建成功的DataAccess对象</returns>
        public static DataAccess CreateDataAccess(DatabaseType databaseType, string dataSource, string database, string tableName, string user, string password)
        ...{
            DataAccess dataAccess = null;
            switch(databaseType)
            ...{
                case DatabaseType.Oracle:
                ...{
                    dataAccess = new OracleDataAccess(dataSource, database, tableName, user, password);
                    break;
                }
                case DatabaseType.SqlServer:
                default:
                ...{
                    dataAccess = new SqlServerDataAccess(dataSource, database, tableName, user, password);
                    break;
                }
            }
            return dataAccess;
        }
        /**//// <summary>
        /// 创建DataAccess对象
        /// </summary>
        /// <param name="databaseType">要创建DataAccess对象的类型</param>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">默认数据库</param>
        /// <param name="tableName">默认表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        /// <param name="selectSql">查询Sql语句</param>
        /// <returns>返回创建成功的DataAccess对象</returns>
        public static DataAccess CreateDataAccess(DatabaseType databaseType, string dataSource, string database, string tableName, string user, string password, string selectSql)
        ...{
            DataAccess dataAccess = null;
            switch(databaseType)
            ...{
                case DatabaseType.Oracle:
                ...{
                    dataAccess = new OracleDataAccess(dataSource, database, tableName, user, password, selectSql);
                    break;
                }
                case DatabaseType.SqlServer:
                default:
                ...{
                    dataAccess = new SqlServerDataAccess(dataSource, database, tableName, user, password, selectSql);
                    break;
                }
            }
            return dataAccess;
        }
    }
}

/**/ /*
 * 名称:        DataAccess.cs
 * 命名空间:    Mouse.Tools.Data
 * 类:            DataAccess
 * 版本:        1.1
 * 说明:
 *     对数据库的操作都通过这个接口类来进行
 * 这个接口类同时也是所有数据操作类的父类
 * 作者:        幸福的耗子
 * 创建日期:    2007.01.29
 * 修改日期:    2007.01.30
 * */
using  System;
using  System.Data;

namespace  Mouse.Tools.Data
... {
    /**//// <summary>
    /// 数据访问接口类
    /// </summary>
    public abstract class DataAccess : IDisposable
    ...{
        /**//// <summary>
        /// 数据源
        /// </summary>
        protected string dataSource;
        /**//// <summary>
        /// 获取数据源
        /// </summary>
        public string DataSource
        ...{
            get
            ...{
                return dataSource;
            }
        }
        /**//// <summary>
        /// 数据库名称
        /// </summary>
        protected string database;
        /**//// <summary>
        /// 获取数据库名称
        /// </summary>
        public string Database
        ...{
            get
            ...{
                return database;
            }
        }
        /**//// <summary>
        /// 访问表表名
        /// </summary>
        protected string tableName;
        /**//// <summary>
        /// 获取访问表表名
        /// </summary>
        public string TableName
        ...{
            get
            ...{
                return tableName;
            }
        }
        /**//// <summary>
        /// 数据库用户
        /// </summary>
        protected string user;
        /**//// <summary>
        /// 获取数据库用户
        /// </summary>
        public string User
        ...{
            get
            ...{
                return user;
            }
        }
        /**//// <summary>
        /// 数据库密码
        /// </summary>
        protected string password;
        /**//// <summary>
        /// 获取数据库密码
        /// </summary>
        public string Password
        ...{
            get
            ...{
                return password;
            }
        }
        /**//// <summary>
        /// 数据库连接对象
        /// </summary>
        protected IDbConnection dbConnection;
        /**//// <summary>
        /// 获取数据库连接对象
        /// </summary>
        public IDbConnection DBConnection
        ...{
            get
            ...{
                return dbConnection;
            }
        }
        /**//// <summary>
        /// 用于操作数据库的对象
        /// </summary>
        protected IDbDataAdapter dataSetCommand;
        /**//// <summary>
        /// 获取用于操作数据的对象
        /// </summary>
        public IDbDataAdapter DataSetCommand
        ...{
            get
            ...{
                return dataSetCommand;
            }
        }
        /**//// <summary>
        /// 查询SQL语句
        /// </summary>
        protected string selectSql;
        /**//// <summary>
        /// 获取查询SQL语句
        /// </summary>
        public string SelectSql
        ...{
            get
            ...{
                return selectSql;
            }
        }
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        public DataAccess(string dataSource, string database, string tableName, string user, string password)
        ...{
            this.dataSource = dataSource;
            this.database = database;
            this.tableName = tableName;
            this.user = user;
            this.password = password;
            this.selectSql = null;
        }
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        /// <param name="selectSql">查询SQL语句</param>
        public DataAccess(string dataSource, string database, string tableName, string user, string password, string selectSql)
        ...{
            this.dataSource = dataSource;
            this.database = database;
            this.tableName = tableName;
            this.user = user;
            this.password = password;
            this.selectSql = selectSql;
        }
        /**//// <summary>
        /// 获取表的所有数据
        /// </summary>
        /// <returns>返回填充了数据的DataSet</returns>
        public abstract DataSet SelectData();
        /**//// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="dataSet">保存了更新数据的DataSet对象</param>
        /// <returns>是否更新成功</returns>
        public abstract bool UpdateData(DataSet dataSet);
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <returns>是否填充成功</returns>
        public abstract bool FillData(DataSet dataSet, string tablename, string commandText);
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <returns>是否填充成功</returns>
        public abstract bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType);
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public abstract bool FillData(DataSet dataSet, string tablename, string commandText, string paramName, object paramValue);
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public abstract bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType, string paramName, object paramValue);
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">SQL命令</param>
        /// <returns>返回影响的行数</returns>
        public virtual int Execute(string commandText)
        ...{
            return Execute(commandText, CommandType.Text);
        }
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">命令</param>
        /// <param name="commandType">命令类型</param>
        /// <returns>返回影响的行数</returns>
        public virtual int Execute(string commandText, CommandType commandType)
        ...{
            IDbCommand dbCommand = DBConnection.CreateCommand();
            dbCommand.CommandText = commandText;
            dbCommand.CommandType = commandType;
            try
            ...{
                return dbCommand.ExecuteNonQuery();
            }
            catch(Exception e)
            ...{
                throw e;
            }
            finally
            ...{
                dbCommand.Connection.Close();
                dbCommand.Dispose();
            }
        }
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">命令</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>返回影响的行数</returns>
        public virtual int Execute(string commandText, string paramName, object paramValue)
        ...{
            return Execute(commandText, CommandType.Text, paramName, paramValue);
        }
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">命令</param>
        /// <param name="commandType">命令类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>返回影响的行数</returns>
        public abstract int Execute(string commandText, CommandType commandType, string paramName, object paramValue);
        /**//// <summary>
        /// 实现对象资源的显式释放
        /// </summary>
        public void Dispose()
        ...{
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        /**//// <summary>
        /// 释放本对象的资源
        /// </summary>
        /// <param name="disposing">是否已经调用GC对象,不要GC对象继续收集此对象的资源</param>
        protected virtual void Dispose(bool disposing)
        ...{
            if(!disposing) return;
            if(null != dbConnection)
            ...{
                if(dbConnection.State != ConnectionState.Closed)
                ...{
                    dbConnection.Close();
                }
                dbConnection.Dispose();
                dbConnection = null;
            }
            if(null != dataSetCommand)
            ...{
                if(null != dataSetCommand.SelectCommand)
                ...{
                    if(null != dataSetCommand.SelectCommand.Connection)
                    ...{
                        dataSetCommand.SelectCommand.Connection.Dispose();
                    }
                    dataSetCommand.SelectCommand.Dispose();
                }
                if(null != dataSetCommand.InsertCommand)
                ...{
                    dataSetCommand.InsertCommand.Dispose();
                }
                if(null != dataSetCommand.UpdateCommand)
                ...{
                    dataSetCommand.UpdateCommand.Dispose();
                }
                if(null != dataSetCommand.DeleteCommand)
                ...{
                    dataSetCommand.DeleteCommand.Dispose();
                }
                dataSetCommand = null;
            }
        }
    }
}

/**/ /*
 * 名称:        OracleDataAccess.cs
 * 命名空间:    Mouse.Tools.Data.DataAccessClass
 * 类:            OracleDataAccess
 * 版本:        1.1
 * 说明:
 *     继承自DataAccess,用于操作Oracle数据库
 * 作者:        幸福的耗子
 * 创建日期:    2007.01.29
 * 修改日期:    2007.01.30
 * */
using  System;
using  System.Data;
using  System.Data.OracleClient;

namespace  Mouse.Tools.Data.DataAccessClass
... {
    /**//// <summary>
    /// 操作Oracle数据库的数据访问类
    /// </summary>
    public class OracleDataAccess : DataAccess
    ...{
        /**//// <summary>
        /// 使用用户名和密码登陆ORACLE数据库
        /// </summary>
        private const string CONST_ORACLE_CONNSTR_USERPASS = "Data Source={0};User Id={1};Password={2}";
        /**//// <summary>
        /// 使用NT验证登陆ORACLE数据库
        /// </summary>
        private const string CONST_ORACLE_CONNSTR_MECHINE = "Data Source={0};Integrated Security=yes";
        /**//// <summary>
        /// SelectCommand对象
        /// </summary>
        private OracleCommand selectCommand;
        /**//// <summary>
        /// CommandBuilder对象
        /// </summary>
        private OracleCommandBuilder commandBuilder;
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        public OracleDataAccess(string dataSource, string database, string tableName, string user, string password)
            :base(dataSource, database, tableName, user, password)
        ...{
        }
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        /// <param name="selectSql">查询SQL语句</param>
        public OracleDataAccess(string dataSource, string database, string tableName, string user, string password, string selectSql)
            :base(dataSource, database, tableName, user, password, selectSql)
        ...{
        }
        /**//// <summary>
        /// 获取表的所有数据
        /// </summary>
        /// <returns>返回填充了数据的DataSet</returns>
        public override DataSet SelectData()
        ...{
            DataSet result = new DataSet();
            try
            ...{
                result.EnforceConstraints = false;
                (GetConnection() as OracleConnection).Open();
                GetDataSetCommand().Fill(result, tableName);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                result.EnforceConstraints = true;
                (GetConnection() as OracleConnection).Close();
            }
            return result;
        }
        /**//// <summary>
        /// 获取SelectCommand对象
        /// </summary>
        /// <returns>SelectCommand对象</returns>
        protected OracleCommand GetSelectCommand()
        ...{
            if(null == selectCommand)
            ...{
                if(null == selectSql)
                    selectCommand = new OracleCommand("SELECT * FROM " + tableName, GetConnection() as OracleConnection);
                else
                    selectCommand = new OracleCommand(selectSql, GetConnection() as OracleConnection);
            }
            return selectCommand;
        }
        /**//// <summary>
        /// 获取数据连接对象
        /// </summary>
        /// <returns>数据连接对象</returns>
        private IDbConnection GetConnection()
        ...{
            if(null == dbConnection)
            ...{
                dbConnection = new OracleConnection(GetConnStr());
            }
            return dbConnection;
        }
        /**//// <summary>
        /// 获取用于操作数据库的对象
        /// </summary>
        /// <returns>用于操作数据库的对象</returns>
        private OracleDataAdapter GetDataSetCommand()
        ...{
            if(null == dataSetCommand)
            ...{
                dataSetCommand = new OracleDataAdapter(GetSelectCommand());
                commandBuilder = new OracleCommandBuilder(dataSetCommand as OracleDataAdapter);
            }
            return dataSetCommand as OracleDataAdapter;
        }
        /**//// <summary>
        /// 获取连接字符串
        /// </summary>
        /// <returns>连接字符串</returns>
        private string GetConnStr()
        ...{
            string connStr = null;
            if(user.Trim().Length != 0)
            ...{
                connStr = String.Format(CONST_ORACLE_CONNSTR_USERPASS, dataSource, user, password);
            }
            else
            ...{
                connStr = String.Format(CONST_ORACLE_CONNSTR_MECHINE, dataSource);
            }
            return connStr;
        }
        /**//// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="dataSet">保存了更新数据的DataSet对象</param>
        /// <returns>是否更新成功</returns>
        public override bool UpdateData(DataSet dataSet)
        ...{
            try
            ...{
                (GetConnection() as OracleConnection).Open();
                GetDataSetCommand().Update(dataSet, tableName);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                (GetConnection() as OracleConnection).Close();
            }
            if(dataSet.HasErrors)
            ...{
                dataSet.Tables[0].GetErrors()[0].ClearErrors();
                return false;
            }
            dataSet.AcceptChanges();
            return true;
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText)
        ...{
            return FillData(dataSet, tablename, commandText, CommandType.Text);
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType)
        ...{
            if(null == dataSet||null == tablename||null == commandText)
                return false;
            if(tablename.Trim().Length == 0||commandText.Trim().Length == 0)
                return false;
            OracleDataAdapter da = new OracleDataAdapter();
            da.SelectCommand = new OracleCommand(commandText, GetConnection() as OracleConnection);
            da.SelectCommand.CommandType = commandType;
            try
            ...{
                GetConnection().Open();
                da.Fill(dataSet, tablename);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                GetConnection().Close();
            }
            return true;
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, string paramName, object paramValue)
        ...{
            return FillData(dataSet, tablename, commandText, CommandType.Text, paramName, paramValue);
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType, string paramName, object paramValue)
        ...{
            if(null == dataSet||null == tablename||null == commandText)
                return false;
            if(tablename.Trim().Length == 0||commandText.Trim().Length == 0)
                return false;
            OracleDataAdapter da = new OracleDataAdapter();
            da.SelectCommand = new OracleCommand(commandText, GetConnection() as OracleConnection);
            da.SelectCommand.CommandType = commandType;
            da.SelectCommand.Parameters.Add(paramName, paramValue);
            try
            ...{
                GetConnection().Open();
                da.Fill(dataSet, tablename);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                GetConnection().Close();
            }
            return true;
        }
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">命令</param>
        /// <param name="commandType">命令类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>返回影响的行数</returns>
        public override int Execute(string commandText, CommandType commandType, string paramName, object paramValue)
        ...{
            IDbCommand dbCommand = DBConnection.CreateCommand();
            dbCommand.CommandText = commandText;
            dbCommand.CommandType = commandType;
            dbCommand.Parameters.Add(new OracleParameter(paramName, paramValue));
            try
            ...{
                return dbCommand.ExecuteNonQuery();
            }
            catch(Exception e)
            ...{
                throw e;
            }
            finally
            ...{
                dbCommand.Connection.Close();
                dbCommand.Dispose();
            }
        }

        /**//// <summary>
        /// 释放本对象的资源
        /// </summary>
        /// <param name="disposing">是否已经调用GC对象,不要GC对象继续收集此对象的资源</param>
        protected override void Dispose(bool disposing)
        ...{
            try
            ...{
                if(!disposing) return;
                if(null != dbConnection)
                ...{
                    dbConnection.Dispose();
                }
                if(null != dataSetCommand)
                ...{
                    (dataSetCommand as OracleDataAdapter).Dispose();
                }
            }
            catch
            ...{
                base.Dispose(disposing);
            }
        }
    }
}

/**/ /*
 * 名称:        SqlServerDataAccess.cs
 * 命名空间:    Mouse.Tools.Data.DataAccessClass
 * 类:            SqlServerDataAccess
 * 版本:        1.1
 * 说明:
 *     继承自DataAccess,用于操作SqlServer数据库
 * 作者:        幸福的耗子
 * 创建日期:    2007.01.29
 * 修改日期:    2007.01.30
 * */
using  System;
using  System.Data;
using  System.Data.SqlClient;

namespace  Mouse.Tools.Data.DataAccessClass
... {
    /**//// <summary>
    /// 操作SqlServer数据库的数据访问类
    /// </summary>
    public class SqlServerDataAccess : DataAccess
    ...{
        /**//// <summary>
        /// 使用用户名和密码登陆SQL数据库
        /// </summary>
        private const string CONST_SQL_CONNSTR_USERPASS = "Data Source={0};Initial Catalog={1};User Id={2};Password={3};";
        /**//// <summary>
        /// 使用NT验证登陆SQL数据库
        /// </summary>
        private const string CONST_SQL_CONNSTR_MACHINE = "Integrated Security=SSPI;Persist Security Info=True;Data Source={0};Initial Catalog={1}";
        /**//// <summary>
        /// SelectCommand对象
        /// </summary>
        private SqlCommand selectCommand;
        /**//// <summary>
        /// CommandBuilder对象
        /// </summary>
        private SqlCommandBuilder commandBuilder;
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        public SqlServerDataAccess(string dataSource, string database, string tableName, string user, string password)
            :base(dataSource, database, tableName, user, password)
        ...{
        }
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataSource">数据源</param>
        /// <param name="database">数据库名称</param>
        /// <param name="tableName">数据表名称</param>
        /// <param name="user">数据库用户</param>
        /// <param name="password">数据库密码</param>
        /// <param name="selectSql">查询SQL语句</param>
        public SqlServerDataAccess(string dataSource, string database, string tableName, string user, string password, string selectSql)
            :base(dataSource, database, tableName, user, password, selectSql)
        ...{
        }
        /**//// <summary>
        /// 获取数据库连接
        /// </summary>
        /// <returns>数据库连接</returns>
        private SqlConnection GetConnection()
        ...{
            if(null == dbConnection)
            ...{
                dbConnection = new SqlConnection(GetConnStr());
            }
            return dbConnection as SqlConnection;
        }
        /**//// <summary>
        /// 获取SelectCommand对象
        /// </summary>
        /// <returns>SelectCommand对象</returns>
        private SqlCommand GetSelectCommand()
        ...{
            if(null == selectCommand)
            ...{
                if(null == selectSql)
                    selectCommand = new SqlCommand("SELECT * FROM " + tableName, GetConnection());
                else
                    selectCommand = new SqlCommand(selectSql, GetConnection());
            }
            return selectCommand;
        }
        /**//// <summary>
        /// 获取用于操作数据库的对象
        /// </summary>
        /// <returns>用于操作数据库的对象</returns>
        private SqlDataAdapter GetDataSetCommand()
        ...{
            if(null == dataSetCommand)
            ...{
                dataSetCommand = new SqlDataAdapter(GetSelectCommand());
                commandBuilder = new SqlCommandBuilder(dataSetCommand as SqlDataAdapter);
            }
            return dataSetCommand as SqlDataAdapter;
        }
        /**//// <summary>
        /// 获取表的所有数据
        /// </summary>
        /// <returns>返回填充了数据的DataSet</returns>
        public override DataSet SelectData()
        ...{
            DataSet result = new DataSet();
            try
            ...{
                result.EnforceConstraints = false;
                (GetConnection() as SqlConnection).Open();
                GetDataSetCommand().Fill(result, tableName);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                result.EnforceConstraints = true;
                (GetConnection() as SqlConnection).Close();
            }
            return result;
        }
        /**//// <summary>
        /// 获取连接字符串
        /// </summary>
        /// <returns>连接字符串</returns>
        private string GetConnStr()
        ...{
            string connStr = null;
            if(user.Trim().Length != 0)
            ...{
                connStr = String.Format(CONST_SQL_CONNSTR_USERPASS, dataSource, database, user, password);
            }
            else
            ...{
                connStr = String.Format(CONST_SQL_CONNSTR_MACHINE, dataSource, database);
            }
            return connStr;
        }
        /**//// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="dataSet">保存了更新数据的DataSet对象</param>
        /// <returns>是否更新成功</returns>
        public override bool UpdateData(DataSet dataSet)
        ...{
            try
            ...{
                (GetConnection() as SqlConnection).Open();
                GetDataSetCommand().Update(dataSet, tableName);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                (GetConnection() as SqlConnection).Close();
            }
            if(dataSet.HasErrors)
            ...{
                dataSet.Tables[0].GetErrors()[0].ClearErrors();
                return false;
            }
            dataSet.AcceptChanges();
            return true;
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText)
        ...{
            return FillData(dataSet, tablename, commandText, CommandType.Text);
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType)
        ...{
            if(null == dataSet||null == tablename||null == commandText)
                return false;
            if(tablename.Trim().Length == 0||commandText.Trim().Length == 0)
                return false;
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = new SqlCommand(commandText, GetConnection());
            da.SelectCommand.CommandType = commandType;
            try
            ...{
                GetConnection().Open();
                da.Fill(dataSet, tablename);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                GetConnection().Close();
            }
            return true;
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, string paramName, object paramValue)
        ...{
            return FillData(dataSet, tablename, commandText, CommandType.Text, paramName, paramValue);
        }
        /**//// <summary>
        /// 填充数据
        /// </summary>
        /// <param name="dataSet">用于保存数据得DataSet</param>
        /// <param name="tablename">要保存得表名称</param>
        /// <param name="commandText">查询命令</param>
        /// <param name="commandType">查询类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>是否填充成功</returns>
        public override bool FillData(DataSet dataSet, string tablename, string commandText, CommandType commandType, string paramName, object paramValue)
        ...{
            if(null == dataSet||null == tablename||null == commandText)
                return false;
            if(tablename.Trim().Length == 0||commandText.Trim().Length == 0)
                return false;
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = new SqlCommand(commandText, GetConnection());
            da.SelectCommand.CommandType = commandType;
            da.SelectCommand.Parameters.Add(paramName, paramValue);
            try
            ...{
                GetConnection().Open();
                da.Fill(dataSet, tablename);
            }
            catch(Exception ex)
            ...{
                throw ex;
            }
            finally
            ...{
                GetConnection().Close();
            }
            return true;
        }
        /**//// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="commandText">命令</param>
        /// <param name="commandType">命令类型</param>
        /// <param name="paramName">参数名称</param>
        /// <param name="paramValue">参数值</param>
        /// <returns>返回影响的行数</returns>
        public override int Execute(string commandText, CommandType commandType, string paramName, object paramValue)
        ...{
            IDbCommand dbCommand = DBConnection.CreateCommand();
            dbCommand.CommandText = commandText;
            dbCommand.CommandType = commandType;
            dbCommand.Parameters.Add(new SqlParameter(paramName, paramValue));
            try
            ...{
                return dbCommand.ExecuteNonQuery();
            }
            catch(Exception e)
            ...{
                throw e;
            }
            finally
            ...{
                dbCommand.Connection.Close();
                dbCommand.Dispose();
            }
        }

        /**//// <summary>
        /// 释放本对象的资源
        /// </summary>
        /// <param name="disposing">是否已经调用GC对象,不要GC对象继续收集此对象的资源</param>
        protected override void Dispose(bool disposing)
        ...{
            try
            ...{
                if(!disposing) return;
                if(null != dbConnection)
                ...{
                    dbConnection.Dispose();
                }
                if(null != dataSetCommand)
                ...{
                    (dataSetCommand as SqlDataAdapter).Dispose();
                }
            }
            catch
            ...{
                base.Dispose(disposing);
            }
        }
    }
}

/**/ /*
 * 名称:        Defines.cs
 * 命名空间:    Mouse.Tools.Data
 * 类:            Defines
 * 版本:        1.0
 * 说明:
 *     包含了所有数据操作相关的类型定义
 * 作者:        幸福的耗子
 * 创建日期:    2007.01.29
 * 修改日期:    2007.01.30
 * */
using  System;

namespace  Mouse.Tools.Data
... {
    /**//// <summary>
    /// 全局定义信息的集合
    /// </summary>
    public sealed class Defines
    ...{
        
    }
    /**//// <summary>
    /// 数据库类型枚举
    /// </summary>
    public enum DatabaseType
    ...{
        /**//// <summary>
        /// SqlServer数据库
        /// </summary>
        SqlServer,
        /**//// <summary>
        /// Oracle数据库
        /// </summary>
        Oracle
    }
}