数据库访问通用类（封装)

最新推荐文章于 2021-12-16 10:15:00 发布
最新推荐文章于 2021-12-16 10:15:00 发布
阅读量155 收藏
点赞数
文章标签： 数据库
原文链接：http://www.cnblogs.com/hnsjack/articles/608676.html
版权

例一：
using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace Db
{
/** <summary>
/// Base 的摘要说明。
/// </summary>
public class Base
{
public Base()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
protected static SqlConnection conn =new SqlConnection(ConfigurationSettings.AppSettings["dsn"]);
protected static SqlCommand cmd = new SqlCommand(strSp,conn);
protected static SqlDataAdapter da = new SqlDataAdapter();
protected static DataSet ds = new DataSet();
protected static DataView dv = new DataView();
protected static SqlDataReader dr;
protected static SqlParameter[] prams;
protected static string strSp;
protected static SqlDataReader drSelectAll(string strSp)
{
cmd.CommandType = CommandType.StoredProcedure;
conn.Open();
dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
return dr;
}//返回一个SqlDataReader
protected static DataSet dsSelectAll(string strSp)
{
da.SelectCommand = new SqlCommand(strSp,conn);
da.SelectCommand.CommandType = CommandType.StoredProcedure;
da.Fill(ds);
conn.Open();
try
{
da.SelectCommand.ExecuteNonQuery();
return ds;
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conn.Dispose();
conn.Close();
}
}//返回一个SqlDataSet
protected static DataView dvSelectAll(string strSp)
{
cmd.CommandType = CommandType.StoredProcedure;
da.SelectCommand = new SqlCommand(strSp,conn);
da.Fill(ds);

conn.Open();
try
{
da.SelectCommand.ExecuteNonQuery();
dv = ds.Tables[0].DefaultView;
return dv;
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conn.Dispose();
conn.Close();
}
}//返回一个DataView
protected static string strCmd(string strSp,SqlParameter[] prams,SqlDataReader dr)
{
CreateCmd(strSp,prams,dr);
conn.Open();
try
{
cmd.ExecuteNonQuery();
return "1";
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conn.Dispose();
conn.Close();
}
}//返回一个数据库操作
protected static SqlCommand CreateCmd(string strSp, SqlParameter[] prams,SqlDataReader dr)
{
cmd.CommandType = CommandType.StoredProcedure;
if (prams != null)
{
foreach (SqlParameter parameter in prams)
cmd.Parameters.Add(parameter);
}
cmd.Parameters.Add(
new SqlParameter("ReturnValue", SqlDbType.Int, 4,
ParameterDirection.ReturnValue, false, 0, 0,
string.Empty, DataRowVersion.Default, null));
return cmd;
}//返回带参数的命令
protected static bool ExecuteSQLs()
{
cmd.CommandType = CommandType.StoredProcedure;
conn.Open();
try
{
int i = (int)cmd.ExecuteScalar();
if(i>0)
{
return true;
}
else
{
return false;
}
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conn.Dispose();
conn.Close();
}
}//返回第一行的数据操作
}
}

——————————————————————————————————————————
示例2

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Collections;

namespace MyCorporation.DepartMent.DataBase
{
    /// <summary>
    /// 通用数据库类
    /// </summary>
    public class DataBase
    {

        private string ConnStr = null;

        public DataBase()
        {
            ConnStr = ConfigurationSettings.AppSettings["ConnStr"];
        }

        public DataBase(string Str)
        {
            try
            {
                this.ConnStr = Str;
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 返回connection对象
        /// </summary>
        /// <returns></returns>
        public SqlConnection ReturnConn()
        {
            SqlConnection Conn = new SqlConnection(ConnStr);
            Conn.Open();
            return Conn;
        }

        public void Dispose(SqlConnection Conn)
        {
            if(Conn!=null)
            {
                Conn.Close();
                Conn.Dispose();
            }
            GC.Collect();
        }

        /// <summary>
        /// 运行SQL语句
        /// </summary>
        /// <param name="SQL"></param>
        public void RunProc(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlCommand Cmd ;
            Cmd = CreateCmd(SQL, Conn);
            try
            {
                Cmd.ExecuteNonQuery();
            }
            catch
            {
                throw new Exception(SQL);
            }
            Dispose(Conn);
            return;
        }

        /// <summary>
        /// 运行SQL语句返回DataReader
        /// </summary>
        /// <param name="SQL"></param>
        /// <returns>SqlDataReader对象.</returns>
        public SqlDataReader RunProcGetReader(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlCommand Cmd ;
            Cmd = CreateCmd(SQL, Conn);
            SqlDataReader Dr;
            try
            {
                Dr = Cmd.ExecuteReader(CommandBehavior.Default);
            }
            catch
            {
                throw new Exception(SQL);
            }
            //Dispose(Conn);
            return Dr;
        }

        /// <summary>
        /// 生成Command对象
        /// </summary>
        /// <param name="SQL"></param>
        /// <param name="Conn"></param>
        /// <returns></returns>
        public SqlCommand CreateCmd(string SQL, SqlConnection Conn)
        {
            SqlCommand Cmd ;
            Cmd = new SqlCommand(SQL, Conn);
            return Cmd;
        }

        /// <summary>
        /// 生成Command对象
        /// </summary>
        /// <param name="SQL"></param>
        /// <returns></returns>
        public SqlCommand CreateCmd(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlCommand Cmd ;
            Cmd = new SqlCommand(SQL, Conn);
            return Cmd;
        }

        /// <summary>
        /// 返回adapter对象
        /// </summary>
        /// <param name="SQL"></param>
        /// <param name="Conn"></param>
        /// <returns></returns>
        public SqlDataAdapter CreateDa(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlDataAdapter Da;
            Da = new SqlDataAdapter(SQL, Conn);
            return Da;
        }

        /// <summary>
        /// 运行SQL语句,返回DataSet对象
        /// </summary>
        /// <param name="procName">SQL语句</param>
        /// <param name="prams">DataSet对象</param>
        public DataSet RunProc(string SQL ,DataSet Ds)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlDataAdapter Da;
            //Da = CreateDa(SQL, Conn);
            Da = new SqlDataAdapter(SQL,Conn);
            try
            {
                Da.Fill(Ds);
            }
            catch(Exception Err)
            {
                throw Err;
            }
            Dispose(Conn);
            return Ds;
        }

        /// <summary>
        /// 运行SQL语句,返回DataSet对象
        /// </summary>
        /// <param name="procName">SQL语句</param>
        /// <param name="prams">DataSet对象</param>
        /// <param name="dataReader">表名</param>
        public DataSet RunProc(string SQL ,DataSet Ds,string tablename)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlDataAdapter Da;
            Da = CreateDa(SQL);
            try
            {
                Da.Fill(Ds,tablename);
            }
            catch(Exception Ex)
            {
                throw Ex;
            }
            Dispose(Conn);
            return Ds;
        }

        /// <summary>
        /// 运行SQL语句,返回DataSet对象
        /// </summary>
        /// <param name="procName">SQL语句</param>
        /// <param name="prams">DataSet对象</param>
        /// <param name="dataReader">表名</param>
        public DataSet RunProc(string SQL , DataSet Ds ,int StartIndex ,int PageSize, string tablename )
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlDataAdapter Da ;
            Da = CreateDa(SQL);
            try
            {
                Da.Fill(Ds, StartIndex, PageSize, tablename);
            }
            catch(Exception Ex)
            {
                throw Ex;
            }
            Dispose(Conn);
            return Ds;
        }

        /// <summary>
        /// 检验是否存在数据
        /// </summary>
        /// <returns></returns>
        public bool ExistDate(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlDataReader Dr ;
            Dr = CreateCmd(SQL,Conn).ExecuteReader();
            if (Dr.Read())
            {
                Dispose(Conn);
                return true;
            }
            else
            {
                Dispose(Conn);
                return false;
            }
        }

        /// <summary>
        /// 返回SQL语句执行结果的第一行第一列
        /// </summary>
        /// <returns>字符串</returns>
        public string Returnvalue(string SQL)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            string result;
            SqlDataReader Dr ;
            try
            {
                Dr = CreateCmd(SQL,Conn).ExecuteReader();
                if (Dr.Read())
                {
                    result = Dr[0].ToString();
                    Dr.Close();
                }
                else
                {
                    result = "";
                    Dr.Close();
                }
            }
            catch
            {
             throw new Exception(SQL);
            }
            Dispose(Conn);
            return result;
        }

        /// <summary>
        /// 返回SQL语句第一列,第ColumnI列,
        /// </summary>
        /// <returns>字符串</returns>
        public string Returnvalue(string SQL, int ColumnI)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            string result;
            SqlDataReader Dr ;
            try
            {
                Dr = CreateCmd(SQL,Conn).ExecuteReader();
            }
            catch
            {
                throw new Exception(SQL);
            }
            if (Dr.Read())
            {
                result = Dr[ColumnI].ToString();
            }
            else
            {
                result = "";
            }
            Dr.Close();
            Dispose(Conn);
            return result;
        }

        /// <summary>
        /// 生成一个存储过程使用的sqlcommand.
        /// </summary>
        /// <param name="procName">存储过程名.</param>
        /// <param name="prams">存储过程入参数组.</param>
        /// <returns>sqlcommand对象.</returns>
        public SqlCommand CreateCmd(string procName, SqlParameter[] prams)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlCommand Cmd = new SqlCommand(procName, Conn);
            Cmd.CommandType = CommandType.StoredProcedure;
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                {
                    if(parameter != null)
                    {
                        Cmd.Parameters.Add(parameter);
                    }
                }
            }
            return Cmd;
        }

        /// <summary>
        /// 为存储过程生成一个SqlCommand对象
        /// </summary>
        /// <param name="procName">存储过程名</param>
        /// <param name="prams">存储过程参数</param>
        /// <returns>SqlCommand对象</returns>
        private SqlCommand CreateCmd(string procName, SqlParameter[] prams,SqlDataReader Dr)
        {
            SqlConnection Conn;
            Conn = new SqlConnection(ConnStr);
            Conn.Open();
            SqlCommand Cmd = new SqlCommand(procName, Conn);
            Cmd.CommandType = CommandType.StoredProcedure;
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                    Cmd.Parameters.Add(parameter);
            }
            Cmd.Parameters.Add(
            new SqlParameter("Returnvalue", SqlDbType.Int, 4,
            ParameterDirection.Returnvalue, false, 0, 0,
            string.Empty, DataRowVersion.Default, null));
            return Cmd;
        }

        /// <summary>
        /// 运行存储过程,返回.
        /// </summary>
        /// <param name="procName">存储过程名</param>
        /// <param name="prams">存储过程参数</param>
        /// <param name="dataReader">SqlDataReader对象</param>
        public void RunProc(string procName, SqlParameter[] prams, SqlDataReader Dr)
        {
            SqlCommand Cmd = CreateCmd(procName, prams, Dr);
            Dr = Cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
            return;
        }

        /// <summary>
        /// 运行存储过程,返回.
        /// </summary>
        /// <param name="procName">存储过程名</param>
        /// <param name="prams">存储过程参数</param>
        public string RunProc(string procName, SqlParameter[] prams)
        {
            SqlDataReader Dr;
            SqlCommand Cmd = CreateCmd(procName, prams);
            Dr = Cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
            if(Dr.Read())
            {
                return Dr.Getvalue(0).ToString();
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// 运行存储过程,返回dataset.
        /// </summary>
        /// <param name="procName">存储过程名.</param>
        /// <param name="prams">存储过程入参数组.</param>
        /// <returns>dataset对象.</returns>
        public DataSet RunProc(string procName,SqlParameter[] prams,DataSet Ds)
        {
            SqlCommand Cmd = CreateCmd(procName,prams);
            SqlDataAdapter Da = new SqlDataAdapter(Cmd);
            try
            {
                Da.Fill(Ds);
            }
            catch(Exception Ex)
            {
                throw Ex;
            }
            return Ds;
        }

    }
}  

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
示例3

using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections;
using System.Collections.Specialized;
using System.Configuration;


namespace IRain.Rheleven.Components
{
 /// <summary>
 /// SqlDabaProvider 的摘要说明。
 /// </summary>
 public class SqlDataProvider : IDisposable
 {
  public SqlDataProvider()
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }

  #region Sql 连接
  private string connectionString = ConfigurationSettings.AppSettings["ConnectionString"] ;

  public string ConnectionString
  {
   get { return connectionString; }
   set { connectionString = value; }
  }

  private SqlConnection GetSqlConnection()
  {
   try
   { return new SqlConnection(connectionString); }
   catch
   {
    throw new ArgumentNullException( "The SqlServer Is Not Valid" );
   }
  }

  #endregion

  #region  运行存储过程
  
  /// <summary>
  ///  运行存储过程 返回存储过程返回值
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <returns>存储过程返回值</returns>
  public int RunProcNonQueryReturn(string procedureName)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection, procedureName, null);
    cmd.ExecuteNonQuery() ;
    sqlConnection.Close();
    return (int)cmd.Parameters["ReturnValue"].Value;
   }
  }

  /// <summary>
  /// 运行存储过程 返回存储过程返回值
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <param name="parameter">存储过程参数</param>
  /// <returns>存储过程返回值</returns>
  public int RunProcNonQueryReturn(string procedureName, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection, procedureName, parameter);
    cmd.ExecuteNonQuery() ;
    sqlConnection.Close();
    return (int)cmd.Parameters["ReturnValue"].Value;
   }
  }

  public void RunProcNonQuery(string procedureName)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection, procedureName, null);
    cmd.ExecuteNonQuery() ;
    sqlConnection.Close();
   }
  }
  
  /// <summary>
  /// 运行存储过程 获取存储过程输出参数值
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <param name="parameter">存储过程参数</param>
  public void RunProcNonQuery(string procedureName, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection, procedureName, parameter);
    cmd.ExecuteNonQuery() ;
    sqlConnection.Close();
   }
  }

  /// <summary>
  /// 运行存储过程
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <returns>返回第一条记录第一个</returns>
  public int RunProcScalar(string procedureName)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection,procedureName,null);
    int tmp;
    tmp = (int)cmd.ExecuteScalar();
    sqlConnection.Close();
    return tmp;
   }
  }


  /// <summary>
  /// 运行存储过程
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <param name="parameter">存储过程参数</param>
  /// <returns>返回第一条记录第一个</returns>
  public int RunProcScalar(string procedureName, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection,procedureName,parameter);
    int tmp;
    tmp = (int)cmd.ExecuteScalar();
    sqlConnection.Close();
    return tmp;
   }
  }

  /// <summary>
  /// 运行存储过程并返回 DataReader
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <returns>返回一个新的 SqlDataReader 对象</returns>
  public SqlDataReader RunProcReader(string procedureName)
  {
   //using ( SqlConnection sqlConnection = GetSqlConnection() )
   //{
   SqlConnection sqlConnection = GetSqlConnection();
   SqlCommand cmd = CreateCommand(sqlConnection, procedureName, null);
   return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
   //}
  }

  /// <summary>
  /// 运行存储过程并返回 DataReader
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <param name="parameter">存储过程参数</param>
  /// <returns>返回一个新的 SqlDataReader 对象</returns>
  public SqlDataReader RunProcReader(string procedureName, SqlParameter[] parameter)
  {
   //using ( SqlConnection sqlConnection = GetSqlConnection() )
   //{
   SqlConnection sqlConnection = GetSqlConnection();
   SqlCommand cmd = CreateCommand(sqlConnection, procedureName, parameter);
   return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
   //}
  }
  
  /// <summary>
  /// 运行存储过程返回DataSet
  /// </summary>
  /// <param name="procedureName">存储过程名</param>
  /// <returns>返回DataSet</returns>
  public DataSet RunProcDataSet(string procedureName)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection,procedureName,null);
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    DataSet dataSet = new DataSet();
    da.Fill(dataSet);
    sqlConnection.Close();
    return dataSet;
   }
  }

  /// <summary>
  /// 运行存储过程返回DataSet
  /// </summary>
  /// <param name="procedureName">存储过程名称</param>
  /// <param name="parameter">存储过程参数</param>
  /// <returns>返回DataSet</returns>
  public DataSet RunProcDataSet(string procedureName, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateCommand(sqlConnection,procedureName,parameter);
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    DataSet dataSet = new DataSet();
    da.Fill(dataSet);
    sqlConnection.Close();
    return dataSet;
   }
  }

  /// <summary>
  /// 创建一个SqlCommand对象以此来执行存储过程
  /// </summary>
  /// <param name="sqlConnection">sql链接</param>
  /// <param name="procedureName">存储过程名称</param>
  /// <param name="parameter">存储过程参数</param>
  /// <returns>返回SqlCommand对象</returns>
  private SqlCommand CreateCommand(SqlConnection sqlConnection, string procedureName, SqlParameter[] parameter)
  {
   if ( sqlConnection.State == System.Data.ConnectionState.Closed )
    sqlConnection.Open();
   SqlCommand command = new SqlCommand(procedureName,sqlConnection);
   command.CommandType = CommandType.StoredProcedure;

   if ( parameter != null )
   {
    foreach( SqlParameter param in parameter)
    {
     command.Parameters.Add( param );
    }
   }

   /// 加入返回参数
   command.Parameters.Add( new SqlParameter("ReturnValue",SqlDbType.Int,4,ParameterDirection.ReturnValue,false,0,0,String.Empty,DataRowVersion.Default,null) );

   return command ;
  }

  #endregion

  #region  生成存储过程参数
  ///  示例
  ///  SqlDataProvider myData = new SqlDataProvider();
  ///  SqlParameter[] prams = { myData.CreateInParam("@ID",SqlDbType.Int,4,1),
  ///         myData.CreateOutParam("@OutParam",SqlDbType.Int,4)
  ///        }


  /// <summary>
  /// 生成存储过程参数
  /// </summary>
  /// <param name="parameterName">存储过程名称</param>
  /// <param name="dataType">参数类型</param>
  /// <param name="size">参数大小</param>
  /// <param name="parameterDirection">参数方向</param>
  /// <param name="parameterValue">参数值</param>
  /// <returns>新的 parameter 对象</returns>
  public SqlParameter CreateParam(string parameterName, SqlDbType dataType, Int32 size, ParameterDirection parameterDirection, object parameterValue)
  {
   SqlParameter parameter ;

   if ( size > 0 )
    parameter = new SqlParameter(parameterName, dataType, size);
   else
    parameter = new SqlParameter(parameterName, dataType);

   parameter.Direction = parameterDirection ;
   if ( !( parameterDirection == ParameterDirection.Output && parameterValue == null ) )
    parameter.Value = parameterValue ;

   return parameter ;
  }

  /// <summary>
  /// 传入输入参数
  /// </summary>
  /// <param name="parameterName">存储过程名称</param>
  /// <param name="dataType">参数类型</param>
  /// <param name="size">参数大小</param>
  /// <param name="parameterValue">参数值</param>
  /// <returns>新的 parameter 对象</returns>
  public SqlParameter CreateInParam(string parameterName, SqlDbType dataType, Int32 size, object parameterValue)
  {
   return CreateParam(parameterName, dataType, size, ParameterDirection.Input, parameterValue);
  }

  /// <summary>
  /// 传入返回值参数
  /// </summary>
  /// <param name="parameterName">存储过程名称</param>
  /// <param name="dataType">参数类型</param>
  /// <param name="size">参数大小</param>
  /// <param name="parameterValue">参数值</param>
  /// <returns>新的 parameter 对象</returns>
  public SqlParameter CreateOutParam(string parameterName, SqlDbType dataType, Int32 size)
  {
   return CreateParam(parameterName, dataType, size, ParameterDirection.Output, null);
  }

  
  #endregion

  #region  运行 SQL 语句
  
  /// <summary>
  /// 运行 SQL 语句 无返回值
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  public void RunSqlNonQuery(string strSql)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection, strSql, null);
    cmd.ExecuteNonQuery();
    sqlConnection.Close();
   }
  }

  /// <summary>
  /// 运行 SQL 语句 无返回值
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <param name="parameter">构建SQL语句参数</param>
  public void RunSqlNonQuery(string strSql, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection, strSql, parameter);
    cmd.ExecuteNonQuery();
    sqlConnection.Close();
   }
  }

  /// <summary>
  /// 运行 SQL 语句
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <returns>返回int</returns>
  public int RunSqlScalar(string strSql)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,null);
    int tmp = (int)cmd.ExecuteScalar();
    sqlConnection.Close();
    return tmp;
   }
  }

  /// <summary>
  ///  运行 SQL 语句
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <param name="parameter">构建SQL语句参数</param>
  /// <returns>返回int</returns>
  public int RunSqlScalar(string strSql, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,parameter);
    int tmp = (int)cmd.ExecuteScalar();
    sqlConnection.Close();
    return tmp;
   }
  }

  /// <summary>
  /// 运行 SQL 语句 返回DataReader
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <returns>返回一个SqlDataReader 对象</returns>
  public SqlDataReader RunSqlReader(string strSql)
  {
   //using ( SqlConnection sqlConnection = GetSqlConnection() )
   //{
    SqlConnection sqlConnection = GetSqlConnection();
    SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,null);
    return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
   //}
  }

  /// <summary>
  /// 运行 SQL 语句 返回DataReader
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <param name="parameter">构建SQL语句参数</param>
  /// <returns>返回一个SqlDataReader 对象</returns>
  public SqlDataReader RunSqlReader(string strSql,  SqlParameter[] parameter)
  {
   //using ( SqlConnection sqlConnection = GetSqlConnection() )
   //{
   SqlConnection sqlConnection = GetSqlConnection();
   SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,parameter);
   return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
   //}
  }

  /// <summary>
  /// 运行 SQL 语句 返回DataSet
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <returns>返回DataSet</returns>
  public DataSet RunSqlDataSet(string strSql)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,null);
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    DataSet dataSet = new DataSet();
    da.Fill(dataSet);
    sqlConnection.Close();
    return dataSet;
   }
  }

  /// <summary>
  /// 运行 SQL 语句 返回DataSet
  /// </summary>
  /// <param name="strSql">SQL语句</param>
  /// <param name="parameter">构建SQL语句参数</param>
  /// <returns>返回DataSet</returns>
  public DataSet RunSqlDataSet(string strSql, SqlParameter[] parameter)
  {
   using ( SqlConnection sqlConnection = GetSqlConnection() )
   {
    SqlCommand cmd = CreateSqlCommand(sqlConnection,strSql,parameter);
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    DataSet dataSet = new DataSet();
    da.Fill(dataSet);
    sqlConnection.Close();
    return dataSet;
   }
  }

  /// <summary>
  /// 根据SQL语句生成 SqlCommand 对象
  /// </summary>
  /// <param name="sqlConnection">SqlConnection 连接</param>
  /// <param name="strSql">SQL语句</param>
  /// <param name="parameter">构造SQL语句参数</param>
  /// <returns>返回一个新的 SqlCommand 对象</returns>
  public SqlCommand CreateSqlCommand(SqlConnection sqlConnection, string strSql, SqlParameter[] parameter)
  {
   if ( sqlConnection.State == System.Data.ConnectionState.Closed )
    sqlConnection.Open();
   SqlCommand command = new SqlCommand(strSql,sqlConnection);

   if ( parameter != null )
   {
    foreach( SqlParameter param in parameter)
    {
     command.Parameters.Add( param );
    }
   }

   return command ;
  }
  #endregion

  #region  生成 构建SQL语句 参数

  /// <summary>
  /// 根据SQL语句生成SqlParameter对象
  /// </summary>
  /// <param name="parameterName">SqlParameter名</param>
  /// <param name="dbType">SqlParameter DbType</param>
  /// <param name="size">SqlParameter 大小</param>
  /// <param name="parameterValue">SqlParameter 值</param>
  /// <returns>返回SqlParameter对象</returns>
  public SqlParameter CreateSqlParam(string parameterName, SqlDbType dbType, Int32 size, object parameterValue)
  {
   SqlParameter parameter ;
   parameter = new SqlParameter(parameterName,dbType,size);
   parameter.Value = parameterValue ;
   return parameter ;
  }
  #endregion

  #region IDisposable 成员

  public void Dispose()
  {
   // TODO:  添加 SqlDabaProvider.Dispose 实现
  }

  #endregion
 }
}

 

转载于:https://www.cnblogs.com/hnsjack/articles/608676.html

weixin_30293079
关注
C＃数据库访问通用实现封装
12-31
数据库访问通用实现封装 C＃实现 不以灵活配置数据库类型，方便。实现三层架构，开发的必要功能，由于技术有效如有错误请大家指正！
SQL数据库通用访问类
武安候的专栏
09-19 911
using System;using System.Configuration;using System.Data;using System.Data.SqlClient;using System.Collections;namespace CFCHINA.TOOLS.DataBase{    ///     /// 通用数据库类    ///     public class DataBas
通用数据库访问类sql server 版本常用方法封装
08-08
/*============================================================================== * * Filename: TSQLServer.cs * Description: 本次常用代码封装为数据库通用访问类： * 包含以下方法： * 1.获取数据库连接字符串,创建数据库连接命令,判断数据字符数组 * 2.执行非查询ExecuteNonQuery返回受影响的行数，增加，修改，删除， * 3.执行Sql语句返回DataRow一行数据信息 * 4.执行Sql语句返回DataTable数据信息 * 5. 执行多条SQL语句，实现数据库事务。如果插入或者修改数据运用事务时候，其中一行报错，将事务回滚。 * 6.在执行命令文本时后，传递sql语句运用Regex re = new Regex(@"@[a-zA-Z0-9]") 则正则表达式进行配匹, * 提高安全性。 * Version: 1.0 * Created: 2012.08.02 * Author: liangjw * Company: Copyright (C) Create Family Wealth Power By Peter * ==============================================================================*/ * 实用方法简单讲解，下面以TSQLServer.cs类为例子： 1.我们最常用的方式就是增删改查，在使用时简单方面，例如我们需要做修改一行记录需要返回DataRow一行记录 需要调用方法调用如下: public static DataRow GetRow(params object[] values) { return TSQLServer.ExecDr("select * from [tb] where id = @1", values); } 2.返回一个DataTable数据集合调用如下： public static DataTable GetTable(object[] s = null) { return TSQLServer.ExecDt("select * from [tb] ", s); } 3.更新一条数据 public static int Update(params object[] values) { return TSQLServer.ExecuteNonQuery(@"update [tb] set test1= @1,test2= @2 where id = @id", values); } 4.插入一条数据 public static int Insert(params object[] values) { return TSQLServer.ExecuteScalar(@"insert into [tb](test1,test2) values(@1,@2);SELECT @@IDENTITY",values).ToInt32(); } * 以上该文件的代码封装的类是部分代码，仅供参考 * 备注信息： 上传部分自己总结的常用方法的封装，有不足和不完美之处，希望大家指出来，愿意一起 * 学习和讨论有关asp.net mvc ,Ajax ,jquery ,,html/css,xml ,sqlserver ,wpf,IIS相关技术的交流和学习。
封装数据通用访问类
spr1ng的专栏
08-05 98
1、链接字符串 2、读取 读取前添加引用 新建类 读取链接字符串 建立链接对象
封装一个通用的数据库操作类
weixin_30635053的博客
10-20 135
最近写一个项目，我开发的方式首先设计数据库，然后用网上免费的代码生成软件CodePlus V2.0生成mode对象，同时封装操作方法，在与数据库操作方面我封装了一个数据操作类，很方便，贡献出来。 Code publicstaticclassSqlPlus { //Hashtabletostorecachedparameters ...
c#.NET万能数据库访问封装类(ACCESS、SQLServer、Oracle)
04-11
本文将深入探讨一个在C#.NET环境中设计的通用数据库访问封装类，该类支持Microsoft Access、SQL Server以及Oracle三种主流数据库系统，旨在提供一种统一的、高效的数据访问方式。 #### 概述 这个封装类，即`...
ADO.NET通用数据库访问类
10-22
ADO.NET通用数据库访问类是开发者为了简化数据库操作而设计的抽象层，它封装了基本的数据库连接、命令执行、数据读取等功能，使得在不同数据库间切换时无需大量修改代码。 在给定的代码示例中，我们看到一个名为`...
封装多种数据库通用访问类
05-11
在数据库访问类的设计中，封装意味着我们将数据库连接、查询语句执行、结果处理等操作都封装在一个类中，外部只需调用相应的公共方法即可。 ASP.NET 2.0 是一个用于构建 Web 应用程序的开发框架，它提供了丰富的...
ASP.NET对SQLServer的通用数据库访问类
10-22
ASP.NET中的`SqlHelper`类是一个通用的数据库访问组件，设计用于简化与SQL Server数据库的交互。这个类封装了常见的数据库操作，如执行查询、存储过程等，使得开发者无需在每次需要与数据库通信时都重复编写相同的...
java数据库访问通用类;
追一个豁达的眼神
02-27 155
package org.studentmanager.commons;/** * java数据库访问通用类; * @author clplain; * */import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import j...
C#通用数据库访问类 常用6种数据库VS2008
06-27
通用数据库访问类 通过配置 可实现不同数据库的的访问&def目前实现了SQLserver&def Oracle&def DataAccess <!----> <!----> <!----> <!----> 调用: IDBOperator idb = DBOperator.GetInstance(); string sqlAccess = @"SELECT * FROM Orders"; DataTable dt = idb.ReturnDataTable(sqlAccess);
数据库操作、访问封装类
01-22
C++使用ADO操作访问数据库的封装类 对连接数据库，获得记录集，执行命令进行了封装讲解， 在本人博客中有配套博文详细介绍： http://blog.csdn.net/MingoJiang
java常用工具类之数据库连接类（可以连接多种数据库）
09-04
主要介绍了java常用工具类之数据库连接类,可以连接多种数据库,代码中包含详细注释,需要的朋友可以参考下
c#(二十九) —— 通用数据库访问类
java能飞翔
12-16 1039
如果项目里需要经常访问数据库，并且使用增删改查等方法，为了方便开发，可使用通用数据库访问类 此处需注意两个事情， 一是为了提高性能，将SQLHelper里的方法均设为static。 二是由于需要在测试类进行读取数据，因此不能在读取数据集方法resultSetQuery()内关闭连接，因此采用System.Data.CommandBehavior.CloseConnection这一枚举变量的方法。 通用数据库访问类 SQLHelper using System.Data.SqlClient; namespa
数据库访问通用类(第四版)
hi_dzj的专栏
01-05 1035
/// ///版本：SQLHelper 2.0 ///修改版本：SQLHelper 1.3 ///模块编号：1001 ///作用：数据库访问通用类 ///作者：邓政军 ///修改日期：2012-1-5 ///新增存储过程 ///新增显示连接关闭操作 /// using System; using System.Collections.Generic; using System.Linq; usi
mysql 数据库操作通用类_C#---数据库访问通用类、Access数据库操作类、mysql类 .
weixin_33146437的博客
01-27 164
//C# 数据库访问通用类 (ADO.NET)using System;using System.Collections.Generic;using System.Text;using System.Data;using System.Data.SqlClient;using System.Configuration;namespace XXX{/// /// 针对SQL Server数据库操作的...
通用数据库访问类
江湖之远
04-17 1519
/********************************************************************************************************* 名称空间:DataBase 模块名称:DAO.cs 类库介绍:实现独立于数库的的DAO类,支持SQL数据提供者|OLEDB数据提供者|ODBC数据提供者          数据库配置信息
数据库访问通用类2
spr1ng的专栏
08-05 100
一、把command的构件提出来 1、初始化工作 2、返回 3、调用 传sql文 事务修改 传命令事务修改，改动少，没啥必要
数据库访问通用类（封装）示例2
Steven.Leong的专栏
11-16 695
using System;using System.Configuration; using System.Data; using System.Data.SqlClient; using System.Collections; namespace MyCorporation.DepartMent.DataBase {     ///     /// 通用数据库类     ///    
NET全数据库访问通用封装
"NET万能数据库访问封装类是一个用于.NET平台的通用数据库访问组件，它可以连接并操作ACCESS、SQL Server、Oracle等不同类型的数据库。该封装类通过设置不同的连接字符串和数据类型参数，实现了对多种数据库的灵活...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值