SqlHelper

最新推荐文章于 2022-03-13 21:29:26 发布
最新推荐文章于 2022-03-13 21:29:26 发布
阅读量415 收藏
点赞数
分类专栏： sql 随笔 c#

 

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

namespace Newer.DataAccess
{
    /// <summary>
    /// 数据库的通用访问代码
    /// 此类为抽象类，不允许实例化，在应用时直接调用即可
    /// </summary>
    public abstract class SqlHelper
    {
        //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
        public static readonly string connString = ConfigurationManager.ConnectionStrings["Newer"].ConnectionString;             

        // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        /// <summary>
        ///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
        /// 使用参数数组形式提供参数列表 
        /// </summary>
        /// <remarks>
        /// 使用示例：
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程，T-SQL语句，等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {

            SqlCommand cmd = new SqlCommand();

            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();

                //清空SqlCommand中的参数列表
                //cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        ///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接 
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例：  
        ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一个现有的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {

            SqlCommand cmd = new SqlCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理 
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例： 
        ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="trans">一个存在的 sql 事物处理</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
/// <summary>
        /// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connection">A valid SqlConnection</param>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        /// <returns>SQL返回的数据集</returns>
        public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {            
            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = false;

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);

                // Create the DataAdapter & DataSet
                using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();

                    // Fill the DataSet using default values for DataTable names, etc
                    da.Fill(ds);

                    // Detach the SqlParameters from the command object, so they can be used again
                    cmd.Parameters.Clear();

                    if (mustCloseConnection)
                        connection.Close();

                    // Return the dataset
                    return ds;
                }
            }
        }

        /// <summary>
        /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例：  
        ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个包含结果的SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            SqlConnection conn = new SqlConnection(connectionString);

            // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
            //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
            //关闭数据库连接，并通过throw再次引发捕捉到的异常。
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                //cmd.Parameters.Clear();
                return rdr;
            }
            catch
            {
                conn.Close();
                throw;
            }
        }

        /// <summary>
        /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。 
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例：  
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例： 
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一个已经存在的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {

            SqlCommand cmd = new SqlCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }
        /// <summary>
        /// 缓存参数数组
        /// </summary>
        /// <param name="cacheKey">参数缓存的键值</param>
        /// <param name="cmdParms">被缓存的参数列表</param>
        public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        /// <summary>
        /// 获取被缓存的参数
        /// </summary>
        /// <param name="cacheKey">用于查找参数的KEY值</param>
        /// <returns>返回缓存的参数数组</returns>
        public static SqlParameter[] GetCachedParameters(string cacheKey)
        {
            SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            //新建一个参数的克隆列表
            SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

            //通过循环为克隆参数列表赋值
            for (int i = 0, j = cachedParms.Length; i < j; i++)
                //使用clone方法复制参数列表中的参数
                clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }

        /// <summary>
        /// 为执行命令准备参数
        /// </summary>
        /// <param name="cmd">SqlCommand 命令</param>
        /// <param name="conn">已经存在的数据库连接</param>
        /// <param name="trans">数据库事物处理</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
        /// <param name="cmdParms">返回带参数的命令</param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {

            //判断数据库连接状态
            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            //判断是否需要事物处理
            if (trans != null)
                cmd.Transaction = trans;

            cmd.CommandType = cmdType;

            if (cmdParms != null)
            {
                foreach (SqlParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
    }
}

 

自制简版

using System;
using System.Collections.Generic;
using System.Text;

using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace _1_SqlHelper
{
    class SqlHelper
    {
        string connStr = ConfigurationManager.ConnectionStrings["str"].ConnectionString;
        /// <summary>
        /// 执行查询
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="param">sql语句中的参数</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sql, params SqlParameter[] param)
        {
            DataTable dt = new DataTable();
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                if (param != null)
                {
                    //添加参数
                    cmd.Parameters.AddRange(param);
                }
                using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
                {
                    //填充datatable
                    sda.Fill(dt);
                }
            }
            return dt;
        }
        public DataTable ExecutDataTable1(string sql, SqlParameter[] param)
        {
            DataTable dt=new DataTable();
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                if(param!=null)
                {
                    cmd.Parameters.AddRange(param);
                }
                using(SqlDataAdapter sda=new SqlDataAdapter(cmd))
                {
                    sda.Fill(dt);
                }
               
            }
            return dt;

        }
        /// <summary>
        /// 执行增删改
        /// </summary>
        /// <param name="sql">要执行的sql语句</param>
        /// <param name="param">参数</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sql, params SqlParameter[] param)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (param != null)
                    {
                        cmd.Parameters.AddRange(param);
                    }
                    conn.Open();
                    return cmd.ExecuteNonQuery();
                }
            }
        }
        /// <summary>
        /// 返回首行首列
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public object ExecuteScalar(string sql, params SqlParameter[] param)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (param != null)
                    {
                        cmd.Parameters.AddRange(param);
                    }
                    conn.Open();
                    return cmd.ExecuteScalar();
                }
            }
        }
        
        /// <summary>
        /// 执行查询返回datareader
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql, params SqlParameter[] param)
        {
            SqlConnection conn = new SqlConnection(connStr);
            SqlCommand cmd = new SqlCommand(sql, conn);
            if (param != null)
            {
                cmd.Parameters.AddRange(param);
            }
            conn.Open();
            //当datareader关闭，对应的连接就关闭
            return cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }
    }
}


使用实例

 

public Form1()
        {
            InitializeComponent();
        }
        SqlHelper helper = new SqlHelper();
        private void button1_Click(object sender, EventArgs e)
        {
            string sql = "select * from student";
            dataGridView1.DataSource = helper.ExecuteDataTable(sql);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
           
        }

        private void button2_Click(object sender, EventArgs e)
        {
            string sql = "select * from student where sSex=@sex";
            dataGridView1.DataSource = helper.ExecuteDataTable(sql, new SqlParameter("@sex", "女"));
        }

        private void button3_Click(object sender, EventArgs e)
        {
            string sql = "select * from student where sSex=@sex and sAge>@age and sClassId=@id";
            SqlParameter[] sps = {
                                 new SqlParameter("@sex","男"),
                                 new SqlParameter("@age",19),
                                 new SqlParameter("@id",4)
                                 };

            dataGridView1.DataSource = helper.ExecuteDataTable(sql,sps);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            string sql = "insert into student(sClassId,sName,sSex,sAge) values(@id,@name,@sex,@age)";
            SqlParameter[] sps = { 
                                    new SqlParameter("@id",2),
                                    new SqlParameter("@name","张三"),
                                    new SqlParameter("@sex","男"),
                                    new SqlParameter("@age",18)
                                 };
            int n = helper.ExecuteNonQuery(sql, sps);
            if (n > 0)
            {
                MessageBox.Show("添加成功");
            }
            else
            {
                MessageBox.Show("失败");
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            string sql = "delete from student where sId in (17,8,9)";
             int n= helper.ExecuteNonQuery(sql);
             if (n > 0)
             {
                 MessageBox.Show(n+"成功");
             }
             else
             {
                 MessageBox.Show("失败");
             }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            string sql = "select count(*) from student";

            object o=  helper.ExecuteScalar(sql);
            int n = Convert.ToInt32(o);
            MessageBox.Show(n.ToString());
        }

        private void button7_Click(object sender, EventArgs e)
        {
            string sql = "select * from student";

            SqlDataReader dr = helper.ExecuteReader(sql);

            while (dr.Read())
            {
                Console.WriteLine(dr["sName"]);
                Console.WriteLine(dr["sSex"]);
                Console.WriteLine(dr["sAge"]);
            }
            dr.Close();

SqlHelper.zip
05-27
SqlHelper是C#编程语言中常见的一种用于简化数据库操作的辅助类库，它为开发者提供了方便的接口，以便更高效地执行SQL语句。在.NET框架下，开发人员经常使用SqlHelper来代替直接操作ADO.NET组件，以提高代码的可读性...
c# SQLHelper(for winForm)实现代码
09-06
C# SQLHelper 实现代码详解 C# SQLHelper 是一个常用的数据库操作类库，主要用于实现数据库的连接、执行 SQL 语句、返回DataReader 等功能。在 WinForm 应用程序中，SQLHelper 通常用于实现数据的CRUD（Create, ...
sqlhelper java_java版sqlhelper
weixin_39827585的博客
02-22 408
这次做LN系统我负责的是连接数据库部分，视频已经录制完成，也传到了网上，希望网友们能指出我的不足，拜谢。下面是这次用到的sqlhelper的代码，权当作是留作备份了。package sql;import java.sql.*;import java.util.logging.*;/*** SQL 基本操作* 通过它,可以很轻松的使用 JDBC 来操纵数据库* @author 郗晓勇*/publi...
sqlhelper java_java 版本SQLHelper
weixin_29117805的博客
02-12 333
package com.jack.SQLHelper;import java.sql.*;import java.util.logging.*;import javax.swing.table.*;/*** SQL 基本操作* 通过它,可以很轻松的使用 JDBC 来操纵数据库* @author Null*/public class SQLHelper{/*** 驱动*/public static...
java sqlhelper_java版sqlhelper(转)
weixin_32697149的博客
02-20 253
packageSql;import java.sql.*;import java.util.logging.*;/*** SQL 基本操作* 通过它,可以很轻松的使用 JDBC 来操纵数据库*/public classSQLHelper{/*** 驱动*/public static String driver = "com.microsoft.sqlserver.jdbc.SQLServerDr...
java sqlhelper_java版本的sqlHelper
weixin_30764401的博客
02-20 426
package com.bobo.util;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.HashMap;import java.uti...
java sqlhelper_SQLHelper 代码细节
weixin_33945547的博客
02-20 182
SQLHelper 具有如下功能：用于获取 sql.properties 配置文件中定义的 SQL 语句(模板)。生成基于单表的 SQL 语句。以下是代码细节：public class SQLHelper {private static final Properties sqlProperties = FileUtil.loadPropertiesFile("sql.properties");pu...
SqlHelper方法
weixin_43522117的博客
03-13 4761
1.SqlHelper介绍 是一个sql的辅助类，可以是代码更简洁，更有可读性！ 2. 类方法方法介绍 retBool(Integerresult):判断数据库操作是否成功 getObject(List<E>list)：从list中取第一条数据返回对应List中泛型的单个结果 fillWrapper(Page<?>page, Wrapper<?>wrapper)：填充Wrapper sqlSession(Class<?>clazz)：获取...
C# SqlHelper
qq_43185226的博客
01-07 330
C# 数据库操作连接
SQLHelper
liyingyan要好好学习
12-18 280
package cn.edu.sicnu.cs.testdb2;import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement;public class SQLHelper { private String ServerName="12
sqlhelper
06-17
### SQLHelper类详解 #### 一、概述 `SQLHelper`类主要负责处理与数据库相关的操作，例如执行SQL语句、获取数据等。该类在.NET框架下开发，利用`System.Data.SqlClient`命名空间中的`SqlConnection`、`SqlCommand`...
ADO.NET自己封装SqlHelper类
04-21
在实际开发中，为了提高代码的复用性和可维护性，开发者常常会自封一个SqlHelper类来简化数据库操作。这个SqlHelper类通常包含了执行SQL语句的基本功能，比如执行非查询操作、查询操作，以及处理参数化查询等。下面...
C# SqlHelper类 （微软官方）
03-07
在.NET框架中，微软提供了一个名为SqlHelper的类，它是一个辅助类，用于简化与SQL Server数据库的交互。这个类通常被用在C#应用程序中，以执行SQL命令和存储过程。SqlHelper类的设计目标是提高代码的可重用性和安全...
12月英语网络统考复习资料2-作文范文汇总.doc
07-15
12月英语网络统考复习资料2-作文范文汇总.doc
15利用公共密钥基础结构配置网络安全性.ppt
07-15
15利用公共密钥基础结构配置网络安全性.ppt
1云金融-任务三-云计算带来的金融变革和发展趋势.pptx
07-15
1云金融-任务三-云计算带来的金融变革和发展趋势.pptx
前端分析-202307110078988
最新发布
07-15
前端分析-202307110078988
Delphi 12.3控件之MakerAI-12.rar
07-15
Delphi 12.3控件之MakerAI-12.rar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值