C# 数据库访问公共类

Web.config配置

 <appSettings>
    <!--数据连接字符串-->
    <add key="DbProviderType" value="Oracle" />
    <add key="ConnectionString" value="Data Source=(DESCRIPTION=
                                              (ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.0.88)(PORT=1521)))
                                              (CONNECT_DATA=(SERVICE_NAME=mestest)));
                                              User Id=hmcs;Password=hmcstest;"/>
  </appSettings>

  <system.data>
    <DbProviderFactories>
      <add name="Odbc Data Provider" invariant="System.Data.Odbc" description=".Net Framework Data Provider for Odbc" type="System.Data.Odbc.OdbcFactory, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
      <add name="OleDb Data Provider" invariant="System.Data.OleDb" description=".Net Framework Data Provider for OleDb" type="System.Data.OleDb.OleDbFactory, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
      <add name="OracleClient Data Provider" invariant="System.Data.OracleClient" description=".Net Framework Data Provider for Oracle" type="System.Data.OracleClient.OracleClientFactory, System.Data.OracleClient, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
      <add name="SqlClient Data Provider" invariant="System.Data.SqlClient" description=".Net Framework Data Provider for SqlServer" type="System.Data.SqlClient.SqlClientFactory, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
      <add name="Oracle Data Provider for .NET" invariant="Oracle.DataAccess.Client" description="Oracle Data Provider for .NET" type="Oracle.DataAccess.Client.OracleClientFactory, Oracle.DataAccess, Version=2.111.6.20, Culture=neutral, PublicKeyToken=89b483f429c47342"/>
      <add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".Net Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite, Version=1.0.58.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139"/>
      <add name="Npgsql Data Provider" invariant="Npgsql" description=".Net Framework Data Provider for PostgreSQL Database" type="Npgsql.NpgsqlFactory, Npgsql, Version=1.98.4.0, Culture=neutral, PublicKeyToken=5d8b90d52f46fda7"/>
    </DbProviderFactories>
  </system.data>

数据库公共类调用方法

DataTable dt = DbUtility.DbUtility.GetInstance().ExecuteDataTable(sql);

数据库公共类

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

namespace DbUtility
{
    /// <summary>
    /// 单例模式实例化数据库操作辅助类
    /// </summary>
    public class DbUtility
    {

        #region 私有字段

        private static readonly string connectionString = ConfigurationManager.AppSettings["ConnectionString"];
        private static readonly string strDbProviderType = ConfigurationManager.AppSettings["DbProviderType"];
        private readonly DbProviderFactory providerFactory;

        #endregion

        #region 公共字段
        /// <summary>
        /// 获取 Web.config文件中配置的 MSSQL 连接的字符串
        /// </summary>
        public string ConnectionString
        {
            get;
            private set;
        }
        #endregion

        #region 创建通用数据库操作类的单一实例

        static volatile DbUtility instance = null;
        static readonly object padlock = new object();

        /// <summary>
        /// 单例模式实例化数据库操作通用类
        /// </summary>
        private DbUtility()
        {
            ConnectionString = connectionString;
            providerFactory = ProviderFactory.GetDbProviderFactory(DbProviderType.SqlServer);
            if (providerFactory == null)
            {
                throw new ArgumentException("Can‘t load DbProviderFactory for given value of providerType");
            }
        }
        /// <summary>
        /// 单例模式实例化数据库操作通用类
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="providerType">数据库类型枚举</param>
        private DbUtility(string connectionString, DbProviderType providerType)
        {
            ConnectionString = connectionString;

            providerFactory = ProviderFactory.GetDbProviderFactory(providerType);
            if (providerFactory == null)
            {
                throw new ArgumentException("Can‘t load DbProviderFactory for given value of providerType");
            }
        }

        /// <summary>
        /// 创建MSSQL数据库操作通用类的单一实例
        /// </summary>
        /// <returns>获取<see cref="LiFeiLin.DBUtility.DbUtility"/>的实例</returns>
        public static DbUtility GetInstance()
        {
           // return GetInstance(connectionString, DbProviderType.SqlServer);
            return GetInstance(connectionString,(DbProviderType)Enum.Parse(typeof(DbProviderType), strDbProviderType));
        }
        /// <summary>
        /// 创建通用数据库操作类的单一实例
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="providerType">数据库类型枚举</param>
        /// <returns>获取<see cref="LiFeiLin.DBUtility.DbUtility"/>的实例</returns>
        public static DbUtility GetInstance(string connectionString, DbProviderType providerType)
        {
            if (instance == null)
            {

                lock (padlock)
                {

                    if (instance == null)
                    {
                        instance = new DbUtility(connectionString, providerType);
                    }
                }
            }
            return instance;
        }
        #endregion

        #region 获取某个表的记录数量
        /// <summary>
        /// 获取某个表的记录数量
        /// </summary>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public int GetDataRecordCount(string tableName)
        {
            return GetDataRecordCount(tableName);
        }
        /// <summary>
        /// 获取某个表的记录数量
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public int GetDataRecordCount(string tableName, string where)
        {
            string strsql = "select count(1) from " + tableName;
            if (where != "")
            {
                strsql += " where " + where;
            }
            object obj = ExecuteScalar(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }
        #endregion

        #region 获取指定表中指定列的最大值
        /// <summary>
        /// 获取指定表中指定列的最大值
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public int GetMaxID(string fieldName, string tableName)
        {
            string strsql = "select max(" + fieldName + ")+1 from " + tableName;
            object obj = ExecuteScalar(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }

        #endregion

        #region 执行一个查询 SQL 语句，并根据返回值判断执行结果是否存在
        /// <summary>
        /// 执行一个查询 SQL 语句，并根据返回值判断执行结果是否存在
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public bool Exists(string strSql)
        {
            object obj = ExecuteScalar(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 执行一个查询 SQL 语句，并根据返回值判断执行结果是否存在
        /// </summary>
        /// <param name="strSql">需要执行的 SQL 查询语句</param>
        /// <param name="cmdParms">结构化参数数组</param>
        /// <returns></returns>
        public bool Exists(string strSql, params DbParameter[] cmdParms)
        {
            object obj = ExecuteScalar(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 表是否存在
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public bool TabExists(string tableName)
        {
            string strsql = "select count(*) from sysobjects where id = object_id(N‘[" + tableName + "]‘) and OBJECTPROPERTY(id, N‘IsUserTable‘) = 1";
            object obj = ExecuteScalar(strsql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

        #region 执行多条SQL语句，实现数据库事务

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public void ExecuteSqlTran(Hashtable sqlStringList)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.Open();
                using (DbTransaction trans = connection.BeginTransaction())
                {
                    DbCommand command = null;
                    try
                    {
                        foreach (DictionaryEntry myDE in sqlStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            DbParameter[] cmdParms = (DbParameter[])myDE.Value;
                            CreateDbCommand(command, connection, trans, cmdText, cmdParms);
                            command.ExecuteNonQuery();
                            command.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        #endregion

        #region 执行一个查询语句，返回一个关联的DataReader实例
        /// <summary>
        /// 执行一个查询语句，返回一个关联的DataReader实例
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sqlString)
        {
            return ExecuteReader(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 执行一个查询语句，返回一个关联的DataReader实例
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sqlString, DbParameter[] parameters)
        {
            return ExecuteReader(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary>
        ///  执行一个查询语句，返回一个关联的DataReader实例
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="commandType">要执行查询语句的类型，如存储过程或者SQl文本命令</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sqlString, CommandType commandType)
        {
            return ExecuteReader(sqlString, commandType, 0, null);
        }

        /// <summary>
        /// 执行一个查询语句，返回一个关联的DataReader实例
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="times">超时时间</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <returns>SqlDataReader</returns>
        public DbDataReader ExecuteReader(string sqlString, int times, params DbParameter[] parameters)
        {
            return ExecuteReader(sqlString, CommandType.Text, times, parameters);
        }

        /// <summary>
        /// 执行一个查询语句，返回一个关联的DataReader实例
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <param name="commandType">执行的SQL语句的类型</param>
        /// <param name="times">超时时间</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters);
            command.Connection.Open();
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }
        #endregion

        #region 执行存储过程
        /// <summary>
        /// 执行存储过程  (使用该方法切记要手工关闭SqlDataReader和连接)
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlDataReader</returns>
        public DbDataReader RunProcedure(string storedProcName, IDbDataParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            connection.ConnectionString = ConnectionString;
            DbDataReader returnReader;
            connection.Open();
            DbCommand command = CreateDbQueryCommand(connection, storedProcName, parameters);
            command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader();
            //Connection.Close(); 不能在此关闭，否则，返回的对象将无法使用
            return returnReader;
        }

        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <returns>DataSet</returns>
        public DataSet RunProcedure(string storedProcName, IDbDataParameter[] parameters, string tableName)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                DataSet dataSet = new DataSet();
                connection.ConnectionString = ConnectionString;
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();
                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <param name="times">储存过程执行超时时间</param>
        /// <returns>DataSet</returns>
        public DataSet RunProcedure(string storedProcName, IDbDataParameter[] parameters, string tableName, int times)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                DataSet dataSet = new DataSet();
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();
                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);
                sqlDA.SelectCommand.CommandTimeout = times;
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>
        /// 执行存储过程后返回执行结果（标识）
        /// </summary>
        /// <param name="storedProcName">储存过程名称</param>
        /// <param name="parameters">储存过程参数</param>
        /// <returns></returns>
        public string RunProcedureState(string storedProcName, IDbDataParameter[] parameters)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();

                DbParameter parameter = providerFactory.CreateParameter();
                parameter.ParameterName = "ReturnValue";
                parameter.DbType = DbType.Int32;
                parameter.Size = 4;
                parameter.Direction = ParameterDirection.ReturnValue;
                parameter.SourceColumnNullMapping = false;
                parameter.SourceColumn = string.Empty;
                parameter.SourceVersion = DataRowVersion.Default;
                parameter.Value = null;

                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);

                sqlDA.SelectCommand.Parameters.Add(parameter); //增加存储过程的返回值参数
                sqlDA.SelectCommand.ExecuteNonQuery();
                connection.Close();
                return sqlDA.SelectCommand.Parameters["ReturnValue"].Value.ToString();
            }
        }

        /// <summary>
        /// 执行存储过程，返回影响的行数
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="rowsAffected">影响的行数</param>
        /// <returns></returns>
        public int RunProcedure(string storedProcName, IDbDataParameter[] parameters, out int rowsAffected)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                int result;
                connection.Open();
                DbCommand command = CreateDbCommand(connection, storedProcName, parameters);
                rowsAffected = command.ExecuteNonQuery();
                result = (int)command.Parameters["ReturnValue"].Value;
                return result;
            }
        }
        #endregion

        #region 执行查询语句并返回DataSet
        /// <summary>
        /// 执行查询语句并返回 <see cref="System.Data.DataSet"/> 对象
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public DataSet ExecuteQuery(string sqlString)
        {
            return ExecuteQuery(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>
        ///执行查询语句并返回 <see cref="System.Data.DataSet"/> 对象
        /// </summary>
        /// <param name="sqlString"></param>
        /// <param name="times"></param>
        /// <returns></returns>
        public DataSet ExecuteQuery(string sqlString, int times)
        {
            return ExecuteQuery(sqlString, CommandType.Text, times, null);
        }
        /// <summary>
        /// 执行查询语句并返回 <see cref="System.Data.DataSet"/> 对象
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <param name="cmdParms">结构化参数</param>
        /// <returns>DataSet</returns>
        public DataSet ExecuteQuery(string sqlString, DbParameter[] parameters)
        {
            return ExecuteQuery(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary>
        /// 执行查询语句并返回 <see cref="System.Data.DataSet"/> 对象
        /// </summary>
        /// <param name="sqlString"></param>
        /// <param name="times"></param>
        /// <param name="cmdParms"></param>
        /// <returns></returns>
        public DataSet ExecuteQuery(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters))
            {
                command.Connection.Open();
                using (DbDataAdapter da = providerFactory.CreateDataAdapter())
                {
                    da.SelectCommand = command;
                    DataSet ds = new DataSet();
                    da.Fill(ds, "ds");
                    command.Parameters.Clear();
                    command.Connection.Close();
                    return ds;
                }
            }
        }
        #endregion

        #region 对数据库执行增删改操作，返回受影响的行数。
        /// <summary>
        /// 对数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="sqlString">要执行的sql命令</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 对数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="sqlString">要执行的增删改的SQL语句</param>
        /// <param name="times">超时时间</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, int times)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, times, null);
        }
        /// <summary>
        /// 对数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="sqlString">要执行的增删改的SQL语句</param>
        /// <param name="parameters">结构化的参数列表</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, DbParameter[] parameters)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary>
        /// 对数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="sqlString">要执行的增删改的SQL语句</param>
        /// <param name="commandType">要执行查询语句的类型，如存储过程或者sql文本命令</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, CommandType commandType)
        {
            return ExecuteNonQuery(sqlString, commandType, 0, null);
        }

        /// <summary>
        /// 对数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="sqlString">要执行的增删改的SQL语句</param>
        /// <param name="commandType">执行的SQL语句的类型</param>
        /// <param name="times">超时时间</param>
        /// <param name="parameters">执行增删改语句所需要的参数</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters))
            {
                command.Connection.Open();
                int affectedRows = command.ExecuteNonQuery();
                command.Connection.Close();
                return affectedRows;
            }
        }
        #endregion

        #region 执行一个查询，返回结果集的首行首列。忽略其他行，其他列
        /// <summary>
        /// 执行一个查询，返回结果集的首行首列。忽略其他行，其他列
        /// </summary>
        /// <param name="sqlString">要执行的SQl命令</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sqlString)
        {
            return ExecuteScalar(sqlString, CommandType.Text, 0, null);
        }

        /// <summary>
        ///  执行一个查询，返回结果集的首行首列。忽略其他行，其他列
        /// </summary>
        /// <param name="sqlString">要执行的SQl命令</param>
        /// <param name="times">执行超时时间</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sqlString, int times)
        {
            return ExecuteScalar(sqlString, CommandType.Text, times, null);
        }
        /// <summary>
        /// 执行一个查询，返回结果集的首行首列。忽略其他行，其他列
        /// </summary>
        /// <param name="sqlString">要执行的SQl命令</param>
        /// <param name="cmdParms">结构化的查询语句</param>
        /// <returns></returns>
        public object ExecuteScalar(string sqlString, params DbParameter[] cmdParms)
        {
            return ExecuteScalar(sqlString, CommandType.Text, 0, cmdParms);
        }

        /// <summary>
        /// 执行一个查询语句，返回查询结果的第一行第一列
        /// </summary>
        /// <param name="sql">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <param name="commandType">执行的SQL语句的类型</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters))
            {
                command.Connection.Open();
                object result = command.ExecuteScalar();
                command.Connection.Close();
                return result;
            }
        }
        #endregion

        #region 执行一个查询语句，返回一个包含查询结果的DataTable
        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="sql">要执行的sql文本命令</param>
        /// <returns>返回查询的结果集</returns>
        public DataTable ExecuteDataTable(string sql)
        {
            return ExecuteDataTable(sql, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="sqlString">要执行的sql文本命令</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sqlString, DbParameter[] parameters)
        {
            return ExecuteDataTable(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="sqlString">要执行的sql语句</param>
        /// <param name="commandType">要执行的查询语句的类型，如存储过程或者sql文本命令</param>
        /// <returns>返回查询结果集</returns>
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType)
        {
            return ExecuteDataTable(sqlString, commandType, 0, null);
        }
        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="sqlString">要执行的sql语句</param>
        /// <param name="commandType">要执行的查询语句的类型</param>
        /// <param name="times">超时时间</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType, int times)
        {
            return ExecuteDataTable(sqlString, commandType, times, null);
        }
        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="times">超时时间</param>
        /// <param name="commandType">执行的SQL语句的类型</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters))
            {
                using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
                {
                    adapter.SelectCommand = command;
                    DataTable data = new DataTable();
                    adapter.Fill(data);
                    return data;
                }
            }
        }
        #endregion

        #region 内部私有方法
        /// <summary>
        /// 构建 DbCommand 对象(用来返回一个结果集，而不是一个整数值)
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="storedProcName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private DbCommand CreateDbQueryCommand(DbConnection connection, string storedProcName, IDbDataParameter[] parameters)
        {
            DbCommand command = providerFactory.CreateCommand();
            command.CommandText = storedProcName;
            command.Connection = connection;
            command.CommandType = CommandType.StoredProcedure;
            foreach (DbParameter parameter in parameters)
            {
                if (parameter != null)
                {
                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="storedProcName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private DbCommand CreateDbCommand(DbConnection connection, string storedProcName, IDbDataParameter[] parameters)
        {
            DbCommand command = CreateDbQueryCommand(connection, storedProcName, parameters);
            DbParameter parameter = providerFactory.CreateParameter();
            parameter.ParameterName = "ReturnValue";
            parameter.DbType = DbType.Int32;
            parameter.Size = 4;
            parameter.Direction = ParameterDirection.ReturnValue;
            parameter.SourceColumnNullMapping = false;
            parameter.SourceColumn = string.Empty;
            parameter.SourceVersion = DataRowVersion.Default;
            parameter.Value = null;
            command.Parameters.Add(((ICloneable)parameter).Clone());
            return command;
        }
        /// <summary>
        /// 创建一个DbCommand对象
        /// </summary>
        /// <param name="cmd">DbCommand对象</param>
        /// <param name="conn">DbConnection数据库连接</param>
        /// <param name="trans">DbTransaction事务对象</param>
        /// <param name="cmdText">执行的SQL语句</param>
        /// <param name="cmdParms">DbParameter参数数组</param>
        private void CreateDbCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, string cmdText, DbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {

                foreach (DbParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
        }
        /// <summary>
        /// 创建一个DbCommand对象
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <param name="commandType">执行的SQL语句的类型</param>
        /// <returns></returns>
        private DbCommand CreateDbCommand(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            DbCommand command = providerFactory.CreateCommand();
            connection.ConnectionString = ConnectionString;
            command.CommandText = sqlString;
            command.CommandType = commandType;
            command.Connection = connection;
            if (times > 0) { command.CommandTimeout = times; }
            if (!(parameters == null || parameters.Length == 0))
            {
                foreach (DbParameter parameter in parameters)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        /// <summary>
        /// 创建一个DbCommand对象
        /// </summary>
        /// <param name="sqlString">要执行的查询语句</param>
        /// <param name="times">超时时间</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数</param>
        /// <returns></returns>
        private DbCommand CreateDbCommand(string sqlString, int times, DbParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            DbCommand command = providerFactory.CreateCommand();
            connection.ConnectionString = ConnectionString;
            command.CommandText = sqlString;
            command.CommandType = CommandType.Text;
            command.Connection = connection;
            command.Transaction = connection.BeginTransaction();

            if (times > 0) { command.CommandTimeout = times; }
            if (!(parameters == null || parameters.Length == 0))
            {
                foreach (DbParameter parameter in parameters)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        #endregion

        #region 获取安全的SQL字符串
        /// <summary>
        /// 获取安全的SQL字符串
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public string GetSafeSQLString(string sql)
        {
            sql = sql.Replace(",", "，");
            sql = sql.Replace(".", "。");
            sql = sql.Replace("(", "（");
            sql = sql.Replace(")", "）");
            sql = sql.Replace(">", "＞");
            sql = sql.Replace("<", "＜");
            sql = sql.Replace("-", "－");
            sql = sql.Replace("+", "＋");
            sql = sql.Replace("=", "＝");
            sql = sql.Replace("?", "？");
            sql = sql.Replace("*", "＊");
            sql = sql.Replace("|", "｜");
            sql = sql.Replace("&", "＆");
            return sql;
        }
        #endregion

        #region 返回当前连接的数据库中所有用户创建的数据库
        /// <summary>
        /// 返回当前连接的数据库中所有用户创建的数据库
        /// </summary>
        /// <returns></returns>
        public DataTable GetTables()
        {
            DataTable table = null;
            using (DbConnection con = providerFactory.CreateConnection())
            {
                con.Open();
                table = con.GetSchema("Tables");

            }
            return table;
        }
        #endregion

    }

    #region 数据库类型枚举
    /// <summary>
    /// 数据库类型枚举
    /// </summary>
    public enum DbProviderType : byte
    {
        /// <summary>
        /// 微软 SqlServer 数据库
        /// </summary>
        SqlServer,
        /// <summary>
        /// 开源 MySql数据库
        /// </summary>
        MySql,
        /// <summary>
        /// 嵌入式轻型数据库 SQLite
        /// </summary>
        SQLite,
        /// <summary>
        /// 甲骨文 Oracle
        /// </summary>
        Oracle,
        /// <summary>
        /// 开放数据库互连
        /// </summary>
        ODBC,
        /// <summary>
        /// 面向不同的数据源的低级应用程序接口
        /// </summary>
        OleDb,
        /// <summary>
        /// 跨平台的关系数据库系统 Firebird
        /// </summary>
        Firebird,
        /// <summary>
        ///加州大学伯克利分校计算机系开发的关系型数据库 PostgreSql
        /// </summary>
        PostgreSql,
        /// <summary>
        /// IBM出口的一系列关系型数据库管理系统 DB2
        /// </summary>
        DB2,
        /// <summary>
        /// IBM公司出品的关系数据库管理系统（RDBMS）家族  Informix
        /// </summary>
        Informix,
        /// <summary>
        /// 微软推出的一个适用于嵌入到移动应用的精简数据库产品 SqlServerCe
        /// </summary>
        SqlServerCe
    }
    #endregion

    #region DbProviderFactory工厂类
    /// <summary>
    /// DbProviderFactory工厂类
    /// </summary>
    public class ProviderFactory
    {
        private readonly static Dictionary<DbProviderType, string> providerInvariantNames = new Dictionary<DbProviderType, string>();
        private readonly static Dictionary<DbProviderType, DbProviderFactory> providerFactoies = new Dictionary<DbProviderType, DbProviderFactory>(20);

        /// <summary>
        /// 加载已知的数据库访问类的程序集
        /// </summary>
        static ProviderFactory()
        {
            providerInvariantNames.Add(DbProviderType.SqlServer, "System.Data.SqlClient");
            providerInvariantNames.Add(DbProviderType.OleDb, "System.Data.OleDb");
            providerInvariantNames.Add(DbProviderType.ODBC, "System.Data.ODBC");
            providerInvariantNames.Add(DbProviderType.Oracle, "Oracle.DataAccess.Client");
            providerInvariantNames.Add(DbProviderType.MySql, "MySql.Data.MySqlClient");
            providerInvariantNames.Add(DbProviderType.SQLite, "System.Data.SQLite");
            providerInvariantNames.Add(DbProviderType.Firebird, "FirebirdSql.Data.Firebird");
            providerInvariantNames.Add(DbProviderType.PostgreSql, "Npgsql");
            providerInvariantNames.Add(DbProviderType.DB2, "IBM.Data.DB2.iSeries");
            providerInvariantNames.Add(DbProviderType.Informix, "IBM.Data.Informix");
            providerInvariantNames.Add(DbProviderType.SqlServerCe, "System.Data.SqlServerCe");
        }
        /// <summary>
        /// 获取指定数据库类型对应的程序集名称
        /// </summary>
        /// <param name="providerType">数据库类型枚举</param>
        /// <returns></returns>
        public static string GetProviderInvariantName(DbProviderType providerType)
        {
            return providerInvariantNames[providerType];
        }
        /// <summary>
        /// 获取指定类型的数据库对应的DbProviderFactory
        /// </summary>
        /// <param name="providerType">数据库类型枚举</param>
        /// <returns></returns>
        public static DbProviderFactory GetDbProviderFactory(DbProviderType providerType)
        {
            //如果还没有加载，则加载该DbProviderFactory
            if (!providerFactoies.ContainsKey(providerType))
            {
                providerFactoies.Add(providerType, ImportDbProviderFactory(providerType));
            }
            return providerFactoies[providerType];
        }
        /// <summary>
        /// 加载指定数据库类型的DbProviderFactory
        /// </summary>
        /// <param name="providerType">数据库类型枚举</param>
        /// <returns></returns>
        private static DbProviderFactory ImportDbProviderFactory(DbProviderType providerType)
        {
            string providerName = providerInvariantNames[providerType];
            DbProviderFactory factory = null;
            try
            {
                //从全局程序集中查找
                factory = DbProviderFactories.GetFactory(providerName);
            }
            catch (ArgumentException e)
            {
                factory = null;
            }
            return factory;
        }
    }
    #endregion
}
时间： 2024-08-12 18:59:49

C# 数据库访问公共类的相关文章

C#---数据库访问通用类、Access数据库操作类、mysql类 .[转]

原文链接 //C# 数据库访问通用类 (ADO.NET)using System;using System.Collections.Generic;using System.Text;using System.Data;using System.Data.SqlClient;using System.Configuration; namespace XXX{    /// <summary>    /// 针对SQL Server数据库操作的通用类           /// </sum

分享最近抽空写的一个代码生成器，集成EasyDBUtility数据库访问帮助类

一直想写一个自己的代码生成器,但是因为工作事情多,一直搁置下来,最近下决心终于利用下班时间写完了,现在分享给有需要的朋友,代码生成器集成EasyDBUtility数据库访问帮助类,暂时只支持sqlserver数据库,界面如下 部分代码如下 using System; using System.Collections.Generic; using System.Data; using System.Data.SqlClient; using System.Linq; using System.Te

Python数据库访问公共组件及模拟Http请求

前言 最近一段时间除了忙于工作之外,在业余时,迷上了python,对它的跨平台深深的吸引.经过一段时间的自我学习,了解了其基本的语法,便开始自己着手摆弄起来.主要想把以前对接的接口再实现一次,以便于在做中发现问题,解决问题.只看不做,没有实际的操练,永远都是纸上谈兵.在此过程中遇到了许多问题,通过不断查询资料和请教基本完善了功能.现将自我觉得比较重要的部分拿出来和大家一起探讨一下,也顺便自己对此做个记录! 模拟Http请求 在请求别人接口时,我们最常使用的是模拟Http请求.在python中有许

C#---数据库访问通用类、Access数据库操作类、mysql类 .

//C# 数据库访问通用类 (ADO.NET)using System;using System.Collections.Generic;using System.Text;using System.Data;using System.Data.SqlClient;using System.Configuration; namespace XXX{    /// <summary>    /// 针对SQL Server数据库操作的通用类           /// </summary&

sqlserver数据库操作公共类DBOperate

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data.SqlClient; using System.Data; using System.Windows.Forms; using  WindowsFormsApplication1.DBTools;//提供数据库连接 namespace liuxw_MPS.DBTools {     ///

sqlserver数据库访问帮助类

1 /// <summary> 2 /// 数据库访问帮助类 3 /// </summary> 4 public static class DbHelper 5 { 6 private const string ConnStr = "server=127.0.0.1;database=db_test;Uid=user1;Pwd=Ps123321;"; 7 8 9 /// <summary> 10 /// 执行 增.删.改 11 /// </su

数据访问公共类

using System; using System.Data; using System.Data.Common; using System.Configuration; using System.Text; using System.Collections.Generic; using System.Data.SqlClient; namespace MDCRM.DAL { /// <summary> /// 数据访问基类 /// </summary> public abstr

【ASP.NET-中级】SQLHelper数据访问公共类

ASP.NET开发中的三层开发思想指的是UI层(界面显示层),BLL层(业务逻辑层),DAL层(数据访问层)三层,三层之间通过函数的调用来达到降低耦合,易于系统维护的目的,SQLHelper助手类的主要作用在于接收并执行来自各个数据表累传来的sql语句或存储过程.一般的SQLHelper类中主要包括以下几个函数功能: 1.执行不带参数的增删改方法 2.执行带参数的增删改方法. 3.执行不带参数的查询方法. 4.执行带参数的查询方法. 作为一个程序员SQLHelper类编写的好坏不仅影响着系统的可

分享我的数据库访问帮助类EasyDBUtility.dll C#

今天有幸被召回母校给即将毕业的学弟学妹们讲我这两年的工作史,看了下母校没啥特别的变化,就是寝室都安了空调,学妹们都非常漂亮而已..好了不扯蛋了,说下今天的主题吧.这些天我在深度定制语法高亮功能的同时发现了博客园提供的一些有意思的函数,甚至有几个博客园都没用到,我也不知道怎么才能触发那些功能..打开这个js就可以看到很多好用的东西了,虽然写的不怎么样,但是至少有这些功能. ps: 推荐安装一个代码格式化的插件,否则一坨看着蛋疼.比如第一个就是 log,方便调试. http://www.ebay.c