数据库通用类DBHelper

最新推荐文章于 2020-01-10 17:17:19 发布
最新推荐文章于 2020-01-10 17:17:19 发布
阅读量1.4k 收藏
点赞数
分类专栏： asp.net 文章标签： 数据库 string dataset null sql server object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_zs/article/details/5553493
版权

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

namespace DAL
{

    /// <summary>
    /// SqlHelper 类是对 SqlClient 类的再次封装
    /// </summary>
    public abstract class SQLHelper
    {
        /// <summary>
        ///  默认的数据库连接字符串
        /// </summary>
        //public static string CONN_STRING = ConfigurationSettings.AppSettings["LandlordManagerConnectionString"].ToString();
        public static string CONN_STRING = ConfigurationManager.ConnectionStrings["conStr"].ToString();

        // 用来缓存参数的哈希表
        private static Hashtable c_ParmCache = Hashtable.Synchronized(new Hashtable());


        #region 构造sqlCommand
        /// <summary>
        /// 构造sqlCommand
        /// </summary>
        /// <param name="sqlCommand">System.Data.SqlClient.SqlCommand</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="sqlConnection">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="sqlTransaction">要在 SQL Server 数据库中处理的 Transact-SQL 事务</param>
        /// <param name="sqlParameter">SQL语句参数</param>
        private static void PrepareCommand(SqlCommand sqlCommand, string commandText, SqlConnection sqlConnection, CommandType commandType, SqlTransaction sqlTransaction, SqlParameter[] sqlParameter)
        {
            if (sqlConnection.State != ConnectionState.Open)
            {
                sqlConnection.Open();
            }
            sqlCommand.Connection = sqlConnection;
            sqlCommand.CommandText = commandText;
            if (sqlTransaction != null)
            {
                sqlCommand.Transaction = sqlTransaction;
            }
            sqlCommand.CommandType = commandType;
            if (sqlParameter != null)
            {
                foreach (SqlParameter iParm in sqlParameter)
                    sqlCommand.Parameters.Add(iParm);
            }
        }
        #endregion

        #region 缓存SQL语句参数/取得缓存的SQL语句参数
        /// <summary>
        /// 缓存SQL语句参数
        /// </summary>
        /// <param name="CacheKey"></param>
        /// <param name="parameters"></param>
        public static void CacheParameters(string CacheKey, params SqlParameter[] parameters)
        {
            c_ParmCache[CacheKey] = parameters;
        }


        /// <summary>
        /// 取得缓存的SQL语句参数
        /// </summary>
        /// <param name="CacheKey"></param>
        /// <returns></returns>
        public static SqlParameter[] GetCachedParameters(string CacheKey)
        {
            SqlParameter[] CachedParms = (SqlParameter[])c_ParmCache[CacheKey];

            if (CachedParms == null)
                return null;

            SqlParameter[] iClonedParms = new SqlParameter[CachedParms.Length];

            for (int i = 0, j = CachedParms.Length; i < j; i++)
            {
                iClonedParms[i] = (SqlParameter)((ICloneable)CachedParms[i]).Clone();
            }

            return iClonedParms;
        }
        #endregion

        #region 由简化的参数构造一个sqlParameter
        /// <summary>
        /// 由简化的参数构造一个sqlParameter
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="sqlDbType">参数类型</param>
        /// <param name="value">参数值</param>
        /// <returns>创建好的sqlParameter</returns>
        public static SqlParameter PrepareParameter(string parameterName, SqlDbType sqlDbType, object value)
        {
            SqlParameter sqlParameter = new SqlParameter(parameterName, value);
            sqlParameter.SqlDbType = sqlDbType;
            return sqlParameter;
        }

        /// <summary>
        /// 由简化的参数构造一个sqlParameter
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="sqlDbType">参数类型</param>
        /// <param name="value">参数值</param>
        /// <param name="size">参数最大字节数</param>
        /// <returns>创建好的sqlParameter</returns>
        public static SqlParameter PrepareParameter(string parameterName, SqlDbType sqlDbType, object value, int size)
        {
            SqlParameter sqlParameter = new SqlParameter(parameterName, value);
            sqlParameter.SqlDbType = sqlDbType;
            sqlParameter.Size = size;
            return sqlParameter;
        }
        #endregion

        #region 对 ExecuteNonQuery 方法的七次重载封装（执行 SQL 语句，返回受影响的行数）
        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText)
        {
            return ExecuteNonQuery(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, params SqlParameter[] parameter)
        {
            return ExecuteNonQuery(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, string connectionString)
        {
            return ExecuteNonQuery(commandText, connectionString, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, string connectionString, CommandType commandType)
        {
            return ExecuteNonQuery(commandText, connectionString, commandType, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, string connectionString, params SqlParameter[] parameter)
        {
            return ExecuteNonQuery(commandText, connectionString, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, string connectionString, CommandType commandType, params SqlParameter[] parameter)
        {
            return ExecuteNonQuery(commandText, connectionString, commandType, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="sqlTransaction">要在 SQL Server 数据库中处理的 Transact-SQL 事务</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string commandText, string connectionString, CommandType commandType, SqlTransaction sqlTransaction, params SqlParameter[] parameter)
        {
            SqlCommand iCommand = new SqlCommand();
            SqlConnection iConn = new SqlConnection(connectionString);
            try
            {
                PrepareCommand(iCommand, commandText, iConn, commandType, sqlTransaction, parameter);
                int iValue = iCommand.ExecuteNonQuery();
                iCommand.Parameters.Clear();
                iConn.Close();
                iConn.Dispose();
                return iValue;
            }
            catch
            {
                iConn.Close();
                throw;
            }
        }
        #endregion

        #region 对 ExecuteScalar 方法的七次重载封装（执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。）
        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText)
        {
            return ExecuteScalar(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, params SqlParameter[] parameter)
        {
            return ExecuteScalar(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, string connectionString)
        {
            return ExecuteScalar(commandText, connectionString, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, string connectionString, CommandType commandType)
        {
            return ExecuteScalar(commandText, connectionString, commandType, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, string connectionString, params SqlParameter[] parameter)
        {
            return ExecuteScalar(commandText, connectionString, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, string connectionString, CommandType commandType, params SqlParameter[] parameter)
        {
            return ExecuteScalar(commandText, connectionString, commandType, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询，并返回查询所返回的结果集中第一行的第一列，忽略其他的列或行。
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="sqlTransaction">要在 SQL Server 数据库中处理的 Transact-SQL 事务</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>查询所返回的结果集中第一行的第一列</returns>
        public static object ExecuteScalar(string commandText, string connectionString, CommandType commandType, SqlTransaction sqlTransaction, params SqlParameter[] parameter)
        {
            SqlCommand iCommand = new SqlCommand();

            using (SqlConnection iConn = new SqlConnection(connectionString))
            {
                PrepareCommand(iCommand, commandText, iConn, commandType, sqlTransaction, parameter);
                object iValue = iCommand.ExecuteScalar();
                iCommand.Parameters.Clear();
                iConn.Close();
                iConn.Dispose();
                return iValue;
            }
        }
        #endregion

        #region 对 ExecuteReader 方法的七次重载封装（执行查询，返回一个 SqlDataReader）
        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText)
        {
            return ExecuteReader(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, params SqlParameter[] parameter)
        {
            return ExecuteReader(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, string connectionString)
        {
            return ExecuteReader(commandText, connectionString, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, string connectionString, CommandType commandType)
        {
            return ExecuteReader(commandText, connectionString, commandType, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, string connectionString, params SqlParameter[] parameter)
        {
            return ExecuteReader(commandText, connectionString, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, string connectionString, CommandType commandType, params SqlParameter[] parameter)
        {
            return ExecuteReader(commandText, connectionString, commandType, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 对连接执行查询并返回一个 SqlDataReader
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="sqlTransaction">要在 SQL Server 数据库中处理的 Transact-SQL 事务</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string commandText, string connectionString, CommandType commandType, SqlTransaction sqlTransaction, params SqlParameter[] parameter)
        {
            SqlCommand iCommand = new SqlCommand();
            SqlConnection iConn = new SqlConnection(connectionString);
            try
            {
                PrepareCommand(iCommand, commandText, iConn, commandType, sqlTransaction, parameter);
                SqlDataReader iReader = iCommand.ExecuteReader(CommandBehavior.CloseConnection);
                iCommand.Parameters.Clear();
                return iReader;
            }
            catch
            {
                iConn.Close();
                throw;
            }
        }
        #endregion

        #region 对 ExecuteTable方法的五次重载封装（使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable）
        /// <summary>
        /// 使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <returns>System.Data.DataTable</returns>
        public static DataTable ExecuteTable(string commandText)
        {
            return ExecuteTable(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>System.Data.DataTable</returns>
        public static DataTable ExecuteTable(string commandText, params SqlParameter[] parameter)
        {
            return ExecuteTable(commandText, CONN_STRING, CommandType.Text, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns>System.Data.DataTable</returns>
        public static DataTable ExecuteTable(string commandText, string connectionString)
        {
            return ExecuteTable(commandText, connectionString, CommandType.Text, (SqlTransaction)null, null);
        }

        /// <summary>
        /// 使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>System.Data.DataTable</returns>
        public static DataTable ExecuteTable(string commandText, string connectionString, CommandType commandType, params SqlParameter[] parameter)
        {
            return ExecuteTable(commandText, connectionString, commandType, (SqlTransaction)null, parameter);
        }

        /// <summary>
        /// 使用 SqlDataAdapter 执行查询并返回 DataSet 的第一个 DataTable
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SQL语句的属性，默认值为CommandType.Text</param>
        /// <param name="sqlTransaction">要在 SQL Server 数据库中处理的 Transact-SQL 事务</param>
        /// <param name="parameter">SQL语句参数</param>
        /// <returns>System.Data.DataTable</returns>
        public static DataTable ExecuteTable(string commandText, string connectionString, CommandType commandType, SqlTransaction sqlTransaction, params SqlParameter[] parameter)
        {
            SqlCommand iCommand = new SqlCommand();
            SqlConnection iConn = new SqlConnection(connectionString);
            try
            {
                PrepareCommand(iCommand, commandText, iConn, commandType, sqlTransaction, parameter);
                using (SqlDataAdapter iDa = new SqlDataAdapter(iCommand))
                {
                    DataSet ds = new DataSet();
                    iDa.Fill(ds);
                    iCommand.Parameters.Clear();

                    iConn.Close();
                    iCommand.Dispose();
                    iConn.Dispose();

                    return ds.Tables[0];
                }
            }
            catch
            {
                iConn.Close();
                throw;
            }
        }
        #endregion

        #region 数据库分页通用存储过程
        /// <summary>
        /// 数据库分页通用存储过程
        /// </summary>
        /// <param name="tblName">表名</param>
        /// <param name="fldName">主键（关键字段）</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">要获取的页码</param>
        /// <param name="orderType">序类型, 0 - 升序, 1 - 降序</param>
        /// <param name="strWhere">查询条件 (注意: 不要加 where)</param>
        /// <param name="output">总记录数</param>
        /// <returns></returns>
        public static DataTable GetRecordFromPage(string tblName, string fldName, int pageSize, int pageIndex, int orderType, string strWhere, ref int output)
        {
            SqlConnection conn = new SqlConnection(SQLHelper.CONN_STRING);
            SqlCommand cmd = new SqlCommand("GetRecordFromPage", conn);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add(new SqlParameter("@tblName", SqlDbType.VarChar, 255));
            cmd.Parameters.Add(new SqlParameter("@fldName", SqlDbType.VarChar, 255));
            cmd.Parameters.Add(new SqlParameter("@PageSize", SqlDbType.Int, 4));
            cmd.Parameters.Add(new SqlParameter("@PageIndex", SqlDbType.Int, 4));
            cmd.Parameters.Add(new SqlParameter("@OrderType", SqlDbType.Bit));
            cmd.Parameters.Add(new SqlParameter("@strWhere", SqlDbType.VarChar, 2000));
            cmd.Parameters.Add(new SqlParameter("@rowTotal", SqlDbType.Int));

            cmd.Parameters[0].Value = tblName;
            cmd.Parameters[1].Value = fldName;
            cmd.Parameters[2].Value = pageSize;
            cmd.Parameters[3].Value = pageIndex;
            cmd.Parameters[4].Value = orderType;
            cmd.Parameters[5].Value = strWhere;
            cmd.Parameters[6].Direction = ParameterDirection.Output;

            try
            {
                conn.Open();
                SqlDataAdapter da = new SqlDataAdapter(cmd);

                DataSet ds = new DataSet();
                da.Fill(ds);

                if (cmd.Parameters[6].Value != DBNull.Value && cmd.Parameters[6].Value.ToString() != string.Empty)
                    output = Convert.ToInt32(cmd.Parameters[6].Value);

                da.Dispose();
                conn.Close();
                conn.Dispose();
                return ds.Tables[0];
            }
            catch (Exception)
            {
                conn.Close();
                return null;
            }
            finally
            {
                cmd.Dispose();
                conn.Dispose();
            }
        }
        #endregion

        #region 数据库分页通用存储过程（可跨库访问）
        /// <summary>
        /// 数据库分页通用存储过程（可跨库访问）
        /// </summary>
        /// <param name="tblName">表名</param>
        /// <param name="fldName">主键（关键字段）</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">要获取的页码</param>
        /// <param name="orderType">序类型, 0 - 升序, 1 - 降序</param>
        /// <param name="strWhere">查询条件 (注意: 不要加 where)</param>
        /// <param name="output">总记录数</param>
        /// <param name="p_ConnString">数据库连接</param>
        /// <returns></returns>
        public static DataTable GetRecordFromPage(string tblName, string fldName, int pageSize, int pageIndex, int orderType, string strWhere, ref int output, string p_ConnString)
        {
            SqlConnection conn = new SqlConnection(p_ConnString);
            SqlCommand cmd = new SqlCommand("GetRecordFromPage", conn);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add(new SqlParameter("@tblName", SqlDbType.VarChar, 255));
            cmd.Parameters.Add(new SqlParameter("@fldName", SqlDbType.VarChar, 255));
            cmd.Parameters.Add(new SqlParameter("@PageSize", SqlDbType.Int, 4));
            cmd.Parameters.Add(new SqlParameter("@PageIndex", SqlDbType.Int, 4));
            cmd.Parameters.Add(new SqlParameter("@OrderType", SqlDbType.Bit));
            cmd.Parameters.Add(new SqlParameter("@strWhere", SqlDbType.VarChar, 2000));
            cmd.Parameters.Add(new SqlParameter("@rowTotal", SqlDbType.Int));

            cmd.Parameters[0].Value = tblName;
            cmd.Parameters[1].Value = fldName;
            cmd.Parameters[2].Value = pageSize;
            cmd.Parameters[3].Value = pageIndex;
            cmd.Parameters[4].Value = orderType;
            cmd.Parameters[5].Value = strWhere;
            cmd.Parameters[6].Direction = ParameterDirection.Output;

            try
            {
                conn.Open();
                SqlDataAdapter da = new SqlDataAdapter(cmd);

                DataSet ds = new DataSet();
                da.Fill(ds);

                if (cmd.Parameters[6].Value != DBNull.Value && cmd.Parameters[6].Value.ToString() != string.Empty)
                    output = Convert.ToInt32(cmd.Parameters[6].Value);

                da.Dispose();
                conn.Close();
                conn.Dispose();
                return ds.Tables[0];
            }
            catch (Exception)
            {
                conn.Close();
                return null;
            }
            finally
            {
                cmd.Dispose();
                conn.Dispose();
            }
        #endregion
        }
    }
}

love_zs
关注
专栏目录
SQLHelper数据库通用类，
06-05
压缩包中包括Microsoft程序员封装的SQLHelper类和本人在实际项目中自己总结的SqlHelper类，可能自己总结的不是很全，希望大家完善，QQ 492415761 共同进步！
DPHELPER DAO 操作数据库
chuanxin4253的博客
09-29 291
package com.example.anzhuo; import java.util.ArrayList; import android.app.Activity; import android.app.AlertDialog; import android.app.Dialog; i...
操作数据库的类DbHelper.cs
yunduan的专栏
03-20 4119
using System;using System.Data;using System.Data.Common;using System.Configuration;namespace Utility{    public class DbHelper    {        private static string dbProviderName = ConfigurationManager.A
DBHelper的两种实现方式
weixin_30679823的博客
06-26 172
Method 1. According to the abstract class of ADO.NET,accomplish the core code of ADO.NET,named DBHelper. Then generate a concrete database ADO.NET object using factory,as the below showing. publi...
EF(Entity Framework)通用DBHelper通用类,增删改查以及列表
weixin_30265103的博客
06-13 748
其中 通用类名:DBhelper 实体类:UserInfo 1 //新增 2 DBHelper<UserInfo> dbhelper = new DBHelper<UserInfo>(); 3 UserInfo userinfo = new UserInfo(); 4 userinfo.Name = "1"; ...
万能数据库通用类DBHelper
09-03
/**//// <summary> ... /// 数据访问基础类 Oracle,SQL Server,Access万能数据库通用类DBHelper /// 用户可以修改满足自己项目的需要。 /// http://blog.csdn.net/fjyts/article/details/6301579 /// </summary>
ASP.NET操作数据库通用类DBHelper
09-07
本文件纯属个人学习参考自编，如有雷同纯属巧合！ 转载请注明原编者。
ASP.NET通用数据库操作类DBHelper
10-08
这个通用的`DBHelper`类是面向接口的编程设计，目的是使其能够与任何类型的数据库系统兼容，例如MySQL、SQL Server、Oracle或SQLite等。下面将详细介绍`DBHelper`类的主要功能和实现原理。 1. **接口式编程**： ...
DBHelper通用数据库操作类v2.1
03-21
1. 支持Micrsoft SQL Server/...2. 支持多数据库同时操作； 3. 支持实体与表映射的直接操作； 4. 支持直接将SQL查询结果转成对应的实体对象； 详细API请参见http://www.tzhtec.com/art/687974b6cb.aspx，附件内附Demo
C#总结：DBHelper类，连接数据库
01-27
DBHelper类是许多开发者自定义创建的一个实用工具类，用于简化数据库的连接和操作过程。在这个总结中，我们将深入探讨DBHelper类及其在C#中连接数据库的应用。 1. DBHelper类的概念： DBHelper类通常是为了封装ADO...
vs2005各种数据库连接函数dbconnection
01-17
vs2005各种数据库连接函数dbconnection
ASP.NET Core3.0(一) --编写SqlHelper通用类连接数据库
weixin_43803985的博客
01-10 5813
一、新建一个.NET Core的工程 文件 二、新建sqlHelper类 需要使用NuGet安装一下文件 System.Data.SqlClient Microsoft.EntityFrameworkCore 以下代码较长，可以先粘贴复制，以后再仔细打磨 using Microsoft.Extensions.Configuration; using Microsoft.Extensions....
C# DBHelper类 参考
技术资料收集站
03-14 2298
using System; using System.Collections.Generic; using System.Text; using System.Configuration; using System.Data; using System.Data.SqlClient; namespace DAL {     public class SQLHelper     {
数据缓存——LKDBHelper的使用
番薯大佬的专栏
04-15 8189
LKDBHelper的使用   https://github.com/li6185377/LKDBHelper-SQLite-ORM   LKDBHelper可以不设置sql语句的情况下，仅使用自定义Model就可以全自动的进行数据表的创建，及数据的插入、查询、更新、删除等操作。 支持 NSArray,NSDictionary, ModelClass, NSNumber, NSStrin
【Java数据库连接类】封装数据库操作的连接类DBConnection
北风
03-12 2792
在项目开发中，操作数据库需要数据库连接对象，通过此公共类能方便的获得数据库连接对象。
dbhelper类，连接数据库
li160620的博客
10-17 7398
这里的类名叫ClsDbOper： using System; using System.Data; using System.Configuration; using System.Web; using System.Text; using System.Data.SqlClient; using System.Windows.Forms; /// /// ClsDbOp
DBHelper类使用
热门推荐
十一的博客
08-18 4万+
1.先在Web.config 文件中加入要连接的数据库 在&lt;configuration&gt;里面加入 &lt;connectionStrings &gt; &lt;add name="logisDb" connectionString="Data Source=.;Initial Catalog=logis;Integrated Security=True"/&...
关于用SqliteOpenHelper进行创建数据库
weixin_33774615的博客
02-27 714
在Android中使用数据库时，会创建一个类继承SQLiteOpenHelper类，在这个类封装数据的增删改查操作，自己写了一个复习了一下 需要注意是在MyDBHelper的构造函数的时候，并没有真正的创建数据库，真正创建数据库，是在调用SQliteOpenHelper的getWritableDatabase( )和getReadableDatabase()方...
万能DBHelper.cs类实现数据库连接管理
在.NET开发中，DBHelper类通常作为数据库操作的辅助工具，它封装了数据库连接的创建、打开、关闭和重置等细节，以提供一个简洁的接口供其他代码调用。在这个例子中，`DBHelp`类定义了两个静态成员：`connection`和`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值