通用数据库操作辅助类DbHelper

使用方式
DbHelper db;
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "SQLite数据文件(*.db3;*.db;*.sqlite)|*.db3;*.db;*.sqlite";
if (ofd.ShowDialog() == DialogResult.OK)
{
    txtDataSource.Text = ofd.FileName;
    db = new DbHelper("data source=" + txtDataSource.Text, DbProvider.Sqlite);
}
db.ReExNum(txtSql.Text); 

接口
using System.Data;
using System.Collections.Generic;
using System.Data.Common;

/// <summary>
/// 该类用于对数据库进行操作
/// Design by 火地晋
/// </summary>
namespace System.Data
{
    public interface IDbObject
    {
        /// <summary>
        /// 定义一个DataReader的列表，已备检索
        /// </summary>
        List<DbDataReader> DataReaderList { get; set; }
        /// <summary>
        /// 
        /// </summary>
        DbConnection Connection { get; set; }
        string ConnectionString { get; set; }
        DbProvider DbProviderType { get; set; }
        
        /// <summary>
        /// 返回执行操作成功的数目，使用注意，如果是存储过程，必须在存储过程后加上：select @@ROWCOUNT
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        int ReExNum(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 返回结果的存储过程
        /// </summary>
        /// <param name="strSql">任何SQL语句</param>
        /// <param name="parameters">参数值</param>
        /// <returns></returns>
        DbDataReader ReSelectdr(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 返回dateSet
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="parameters"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        DataSet ReSelectds(string strSql, string tableName, params DbParameter[] parameters);
        DataTable ReSelectdtb(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 通過存儲過程及自定義參數組查詢返回SqlDataAdapter對象
        /// </summary>
        DbDataAdapter ReSelectdat(string strSql, params DbParameter[] parameters);

        void ExSQL(string strSql, params DbParameter[] parameters);
        /// <summary>
        ///     執行SQL查詢語句,返回記錄條數
        /// </summary>
        /// <param name="strSql">Select語句(在select语句中,使用Count(*)函数)</param>
        /// <returns>返回查詢到之記錄條數</returns>
        int ReSelectNum(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 使用SqlDataAdapter返回指定范围的数据
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数名</param>
        /// <param name="start">起始行</param>
        /// <param name="maxRecord">记录数</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        DataSet ReSelectds(string strSql, DbParameter[] parameters, int start, int maxRecord, string tableName);
        /// <summary>
        /// 返回执行操作成功的数目，不关闭连接
        /// </summary>
        /// <param name="strSql">执行的查询语句或存储过程</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        int ReExNumNoClose(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 返回执行操作成功的数目，不关闭连接，并返回出现的错误信息。
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        int ReExNumNoClose(string strSql, out string error, params DbParameter[] parameters);

        /// <summary>
        /// 返回执行操作成功的数目，并返回发生的错误信息
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        int ReExNum(string strSql, out string error, params DbParameter[] parameters);

        /// <summary>
        /// 返回执行操作结果的信息，如果返回为空则表示没错误，否则返回错误的信息。
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        string ReExStr(string strSql, params DbParameter[] parameters);
        /// <summary>
        /// 如果数据库连接已关闭,则打开
        /// </summary>
        /// <returns></returns>
        bool OpenConnection();
        /// <summary>
        /// 关闭数据库连接
        /// </summary>
        void CloseConnection();
    }
    public enum DbProvider
    {
        Sql=0,
        Sqlite=1,
        OleDb=2,
        Oracle=3,
        MySql=4
    }
}
 
类
using System;
using System.Collections.Generic;
using System.Text;
using System.Data.Common;

namespace System.Data
{
    public class DbHelper : IDbObject
    {
        #region 属性
        public List<DbDataReader> DataReaderList { get; set; }
        public DbConnection Connection { get; set; }
        public string ConnectionString { get; set; }
        public DbProvider DbProviderType { get; set; }
        private DbProviderFactory dbFactory;
        #endregion

        #region 构造函数
        public DbHelper()
        {
            DbHelperInstance(System.Configuration.ConfigurationManager.AppSettings["ConnectionString"], DbProvider.Sql);
        }
        public DbHelper(string connectionString)
        {
            DbHelperInstance(connectionString, DbProvider.Sql);
        }
        public DbHelper(DbProvider dbProviderType)
        {
            DbHelperInstance(System.Configuration.ConfigurationManager.AppSettings["ConnectionString"], dbProviderType);
        }
        public DbHelper(string connectionString, DbProvider dbProviderType)
        {
            DbHelperInstance(connectionString, dbProviderType);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="dbProviderType"></param>
        public void DbHelperInstance(string connectionString, DbProvider dbProviderType)
        {
            this.DbProviderType = dbProviderType;
            this.ConnectionString = connectionString;
            DataReaderList = new List<DbDataReader>();
            CreateFactory();
            this.Connection = this.dbFactory.CreateConnection();
            this.Connection.ConnectionString = this.ConnectionString;
        }
        #endregion
        /// <summary>
        /// 创建数据操作工厂
        /// </summary>
        private void CreateFactory()
        {
            switch (DbProviderType)
            {
                case DbProvider.Sql:
                    this.dbFactory = System.Data.SqlClient.SqlClientFactory.Instance;
                    break;
                case DbProvider.Sqlite:
                    this.dbFactory = System.Data.SQLite.SQLiteFactory.Instance;
                    break;
                case DbProvider.OleDb:
                    this.dbFactory = System.Data.OleDb.OleDbFactory.Instance;
                    break;
                case DbProvider.Oracle:
                    this.dbFactory = System.Data.OracleClient.OracleClientFactory.Instance;
                    break;
                case DbProvider.MySql:
                    this.dbFactory = MySql.Data.MySqlClient.MySqlClientFactory.Instance;
                    break;
            }
        }
        /// <summary>
        /// 创建操作对象
        /// </summary>
        /// <param name="procNameOrExText">如果包含@,则采用CommandType.Text</param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private DbCommand BuilderQueryCommand(string procNameOrExText, params DbParameter[] parameters)
        {
            if (parameters == null || parameters.Length == 0)
            {
                DbCommand command = this.dbFactory.CreateCommand();
                command.CommandText = procNameOrExText;
                command.Connection = this.Connection;
                return command;
            }
            if (procNameOrExText.IndexOf('@') > 0)//存储过程
            {
                return BuilderQueryCommandText(procNameOrExText, parameters);
            }
            else
            {
                return BuilderQueryCommandStorPro(procNameOrExText, parameters);
            }
        }

        /// <summary>
        /// 根据存储过程名称和参数生成对应的SQL命令对象
        /// </summary>
        /// <param name="strSql">存储过程名或者</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns></returns>
        private DbCommand BuilderQueryCommandStorPro(string strSql, params DbParameter[] parameters)
        {
            DbCommand command = this.dbFactory.CreateCommand();
            command.CommandText = strSql;
            command.CommandType = CommandType.StoredProcedure;
            command.Connection = this.Connection;
            if (parameters != null)
            {
                foreach (DbParameter p in parameters)
                {
                    command.Parameters.Add(p);
                }
            }
            return command;
        }
        private DbCommand BuilderQueryCommandText(string strSql, params DbParameter[] parameters)
        {
            DbCommand command = this.dbFactory.CreateCommand();
            command.CommandText = strSql;
            command.Connection = this.Connection;
            if (parameters != null)
            {
                foreach (DbParameter p in parameters)
                {
                    command.Parameters.Add(p);
                }
            }
            return command;
        }
        public DbParameter CreateDbParameter(string parameterName)
        {
            return CreateDbParameter(parameterName, DBNull.Value, DbType.Object, 0, ParameterDirection.Input);
        }
        public DbParameter CreateDbParameter(string parameterName, object value)
        {
            return CreateDbParameter(parameterName, value, DbType.Object, 0, ParameterDirection.Input);
        }
        public DbParameter CreateDbParameter(string parameterName, object value, DbType dbType)
        {
            return CreateDbParameter(parameterName,value,dbType,0,ParameterDirection.Input);
        }
        public DbParameter CreateDbParameter(string parameterName, object value, DbType dbType, int size)
        {
            return CreateDbParameter(parameterName,value,dbType,size,ParameterDirection.Input);
        }
        public DbParameter CreateDbParameter(string parameterName, object value, DbType dbType, int size, ParameterDirection parameterDirection)
        {
            DbParameter pat = this.dbFactory.CreateParameter();
            pat.ParameterName = parameterName;
            pat.Value = value;
            pat.DbType = dbType;
            pat.Size = size;
            pat.Direction = parameterDirection;
            return pat;
        }
        /// <summary>
        /// 返回执行操作成功的数目，使用注意，如果是存储过程，必须在存储过程后加上：select @@ROWCOUNT
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        public int ReExNum(string strSql, params DbParameter[] parameters)
        {
            int effect = 0;
            if (!OpenConnection()) return -1;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                //根据是否为存储过程来执行不同的处理
                if (cmd.CommandType == CommandType.StoredProcedure)
                {
                    object result = cmd.ExecuteScalar();
                    effect = result == null ? -1 : Convert.ToInt16(result);
                }
                else
                {
                    effect = cmd.ExecuteNonQuery();
                }
                trans.Commit();
                return effect;
            }
            catch
            {
                trans.Rollback();
                Connection.Close();
                return -1;
            }
            finally
            {
                Connection.Close();
            }
        }
        /// <summary>
        /// 返回结果的存储过程
        /// </summary>
        /// <param name="strSql">任何SQL语句</param>
        /// <param name="parameters">参数值</param>
        /// <returns></returns>
        public DbDataReader ReSelectdr(string strSql, params DbParameter[] parameters)
        {
            try
            {
                DbDataReader reader;
                if (!OpenConnection()) return null;
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);//在dr关闭之后,就不需要进行cnn的关闭操作了
                DataReaderList.Add(reader);//添加进dr列表,已备检索
                return reader;
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 返回dateSet
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="parameters"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public DataSet ReSelectds(string strSql, string tableName, params DbParameter[] parameters)
        {
            try
            {
                DataSet ds = new DataSet();
                if (!OpenConnection()) return null;
                DbDataAdapter myDa = this.dbFactory.CreateDataAdapter();
                myDa.SelectCommand = BuilderQueryCommand(strSql, parameters);
                myDa.Fill(ds, tableName);
                return ds;
            }
            catch
            {
                return null;
            }
            finally
            {
                Connection.Close();
            }
        }
        public DataTable ReSelectdtb(string strSql, params DbParameter[] parameters)
        {
            try
            {
                DataTable dt = new DataTable();
                if (!OpenConnection()) return null;
                DbDataAdapter myDa = this.dbFactory.CreateDataAdapter();
                myDa.SelectCommand = BuilderQueryCommand(strSql, parameters);
                myDa.Fill(dt);
                return dt;
            }
            catch
            {
                return null;
            }
            finally
            {
                Connection.Close();
            }
        }
        /// <summary>
        /// 通過存儲過程及自定義參數組查詢返回SqlDataAdapter對象
        /// </summary>
        public DbDataAdapter ReSelectdat(string strSql, params DbParameter[] parameters)
        {
            if (!OpenConnection()) return null;
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                DbDataAdapter myDa = this.dbFactory.CreateDataAdapter();
                myDa.SelectCommand = cmd;
                return myDa;
            }
            catch
            {
                Connection.Close();
                return null;
            }
        }

        public void ExSQL(string strSql, params DbParameter[] parameters)
        {
            if (!OpenConnection()) return;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                cmd.ExecuteNonQuery();
                trans.Commit();
            }
            catch
            {
                trans.Rollback();
                Connection.Close();
                return;
            }
            finally
            {
                Connection.Close();
            }
        }
        /// <summary>
        ///  執行SQL查詢語句,返回記錄條數
        /// </summary>
        /// <param name="strSql">Select語句(在select语句中,使用Count(*)函数)</param>
        /// <returns>返回查詢到之記錄條數</returns>
        public int ReSelectNum(string strSql, params DbParameter[] parameters)
        {
            int effect = 0;
            try
            {
                DbDataReader dr = ReSelectdr(strSql, parameters);
                if (dr.Read())
                {
                    effect = Convert.ToInt32(dr.GetValue(0));
                }
                return effect;
            }
            catch
            {
                return effect;

            }
        }
        /// <summary>
        /// 使用SqlDataAdapter返回指定范围的数据
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数名</param>
        /// <param name="start">起始行</param>
        /// <param name="maxRecord">记录数</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public DataSet ReSelectds(string strSql, DbParameter[] parameters, int start, int maxRecord, string tableName)
        {
            try
            {
                DataSet ds = new DataSet();
                OpenConnection();
                DbDataAdapter myDa = this.dbFactory.CreateDataAdapter();
                myDa.SelectCommand = BuilderQueryCommand(strSql, parameters);
                myDa.Fill(ds, start, maxRecord, tableName);
                return ds;
            }
            catch
            {
                Connection.Close();
                return null;
            }
            finally
            {
                Connection.Close();
            }
        }
        /// <summary>
        /// 返回执行操作成功的数目，不关闭连接
        /// </summary>
        /// <param name="strSql">执行的查询语句或存储过程</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        public int ReExNumNoClose(string strSql, params DbParameter[] parameters)
        {
            int effect = 0;
            if (!OpenConnection()) return -1;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                //根据是否为存储过程来执行不同的处理
                if (cmd.CommandType == CommandType.StoredProcedure)
                {
                    object result = cmd.ExecuteScalar();
                    effect = result == null ? -1 : Convert.ToInt16(result);
                }
                else
                {
                    effect = cmd.ExecuteNonQuery();
                }
                trans.Commit();
                return effect;
            }
            catch
            {
                trans.Rollback();
                return effect;
            }
        }
        /// <summary>
        /// 返回执行操作成功的数目，不关闭连接，并返回出现的错误信息。
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        public int ReExNumNoClose(string strSql, out string error, params DbParameter[] parameters)
        {
            int effect = 0;
            error = "";
            if (!OpenConnection()) return -1;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                if (cmd.CommandType == CommandType.StoredProcedure)
                {
                    object result = cmd.ExecuteScalar();
                    effect = result == null ? -1 : Convert.ToInt16(result);
                }
                else
                {
                    effect = cmd.ExecuteNonQuery();
                }
                effect = cmd.ExecuteNonQuery();
                trans.Commit();
                return effect;
            }
            catch (Exception ex)
            {
                trans.Rollback();
                error = ex.Message;
                return effect;
            }
        }

        /// <summary>
        /// 返回执行操作成功的数目，并返回发生的错误信息
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        public int ReExNum(string strSql, out string error, params DbParameter[] parameters)
        {
            int effect = 0;
            error = "";
            if (!OpenConnection()) return -1;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                if (cmd.CommandType == CommandType.StoredProcedure)
                {
                    object result = cmd.ExecuteScalar();
                    effect = result == null ? -1 : Convert.ToInt16(result);
                }
                else
                {
                    effect = cmd.ExecuteNonQuery();
                }
                trans.Commit();
                return effect;
            }
            catch (Exception ex)
            {
                trans.Rollback();
                error = ex.Message;
                return effect;
            }
            finally
            {
                Connection.Close();
            }
        }

        /// <summary>
        /// 返回执行操作结果的信息，如果返回为空则表示没错误，否则返回错误的信息。
        /// </summary>
        /// <param name="strSql">存储过程名</param>
        /// <param name="parameters">参数组</param>
        /// <returns></returns>
        public string ReExStr(string strSql, params DbParameter[] parameters)
        {
            string error = string.Empty;
            int effect = 0;
            if (!OpenConnection()) return null;
            DbTransaction trans = Connection.BeginTransaction();
            try
            {
                DbCommand cmd = BuilderQueryCommand(strSql, parameters);
                cmd.Transaction = trans;
                effect = cmd.ExecuteNonQuery();
                trans.Commit();
                if (effect == 0)
                {
                    error = "操作成功记录数为0，请检查意外的错误。" + " sql语句：" + strSql;
                }
                else
                {
                    error = "";
                }
            }
            catch (Exception ex)
            {
                trans.Rollback();
                error = "sql语句：" + strSql + " 错误信息：" + ex.Message;
            }
            finally
            {
                Connection.Close();
            }
            return error;
        }
        /// <summary>
        /// 如果数据库连接已关闭,则打开
        /// </summary>
        /// <returns></returns>
        public bool OpenConnection()
        {
            if (Connection.State == ConnectionState.Closed)
            {
                try
                {
                    Connection.Open();
                }
                catch
                {
                    return false;
                }
            }
            return true;
        }
        public void CloseConnection()
        {
            Connection.Close();
        }
    }
}