.NET DataHelper共通类

已于 2023-08-29 08:39:57 修改
阅读量240 收藏
点赞数
分类专栏： .NET技术 数据库技术前沿 文章标签： .net 数据库
于 2023-08-25 11:22:11 首次发布
原文链接：https://www.ngui.cc/el/1774815.html
版权

最近在做.NET开发时，每个项目每次都要写数据库连接，CRUD的操作，效率很慢，在时间之余整理了一个通用类（DataHelper.cs）。希望帮助学习的人，同样哪里有错误请诸位指正（改不改我的事，哈哈哈）

→→→→→多了不说，少了不唠。进入正题→→→→

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

namespace APITool.Util
{
    public class DataHelper
    {
        protected static string connectionString = ConfigurationManager.ConnectionStrings["APITool.Properties.Settings.SqlServerConnection"].ConnectionString;
        DbProviderFactory provider;

        public DataHelper()
        {
            provider = DbProviderFactories.GetFactory(ConfigurationManager.ConnectionStrings["APITool.Properties.Settings.SqlServerConnection"].ProviderName);
        }

        /// <summary>
        /// 执行SQL语句，返回记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public int ExecuteSql(string SQLString)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    cmd.Connection = connection;
                    cmd.CommandText = SQLString;
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (DbException e)
                    {
                        connection.Close();
                        connection.Dispose();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>        
        public void ExecuteSqlTran(ArrayList SQLStringList)
        {
            using (DbConnection conn = provider.CreateConnection())
            {
                conn.ConnectionString = connectionString;
                conn.Open();
                using (DbCommand cmd = provider.CreateCommand())
                {
                    cmd.Connection = conn;
                    using (DbTransaction tx = conn.BeginTransaction())
                    {
                        cmd.Transaction = tx;
                        try
                        {
                            for (int n = 0; n < SQLStringList.Count; n++)
                            {
                                string strsql = SQLStringList[n].ToString();
                                if (strsql.Trim().Length > 1)
                                {
                                    cmd.CommandText = strsql;
                                    cmd.ExecuteNonQuery();
                                }
                            }
                            tx.Commit();
                        }
                        catch (DbException ex)
                        {
                            tx.Rollback();
                            conn.Close();
                            conn.Dispose();
                            throw ex;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public object GetSingle(string SQLString)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    cmd.Connection = connection;
                    cmd.CommandText = SQLString;
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (DbException e)
                    {
                        connection.Close();
                        connection.Dispose();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回SqlDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public DbDataReader ExecuteReader(string strSQL)
        {
            DbConnection connection = provider.CreateConnection();
            connection.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            cmd.Connection = connection;
            cmd.CommandText = strSQL;
            try
            {
                connection.Open();
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return myReader;
            }
            catch (System.Data.Common.DbException e)
            {
                connection.Close();
                connection.Dispose();
                throw new Exception(e.Message);
            }

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public DataSet GetDataSet(string SQLString)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    cmd.Connection = connection;
                    cmd.CommandText = SQLString;
                    try
                    {
                        DataSet ds = new DataSet();
                        DbDataAdapter adapter = provider.CreateDataAdapter();
                        adapter.SelectCommand = cmd;
                        adapter.Fill(ds, "ds");
                        return ds;
                    }
                    catch (DbException ex)
                    {
                        connection.Close();
                        connection.Dispose();
                        throw new Exception(ex.Message);
                    }
                }
            }
        }
        
        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public int ExecuteSql(string SQLString, DbParameter[] cmdParms)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    cmd.Connection = connection;
                    cmd.CommandText = SQLString;
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (DbException E)
                    {
                        connection.Close();
                        connection.Dispose();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (DbConnection conn = provider.CreateConnection())
            {
                conn.ConnectionString = connectionString;
                conn.Open();
                using (DbTransaction trans = conn.BeginTransaction())
                {
                    using (DbCommand cmd = provider.CreateCommand())
                    {
                        try
                        {
                            //循环
                            foreach (DictionaryEntry myDE in SQLStringList)
                            {
                                string cmdText = myDE.Key.ToString();
                                DbParameter[] cmdParms = (DbParameter[])myDE.Value;
                                PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                                int val = cmd.ExecuteNonQuery();
                                cmd.Parameters.Clear();
                            }
                            trans.Commit();
                        }
                        catch (DbException ex)
                        {
                            trans.Rollback();
                            conn.Close();
                            conn.Dispose();
                            throw ex;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）,返回首行首列的值;
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public object GetSingle(string SQLString, DbParameter[] cmdParms)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (DbException e)
                    {
                        connection.Close();
                        connection.Dispose();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回SqlDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public DbDataReader ExecuteReader(string SQLString, DbParameter[] cmdParms)
        {
            DbConnection connection = provider.CreateConnection();
            connection.ConnectionString = connectionString;
            DbCommand cmd = provider.CreateCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (DbException e)
            {
                connection.Close();
                connection.Dispose();
                throw new Exception(e.Message);
            }

        }

        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataTable</returns>
        public DataTable GetDataSet(string SQLString, DbParameter[] cmdParms)
        {
            using (DbConnection connection = provider.CreateConnection())
            {
                connection.ConnectionString = connectionString;
                using (DbCommand cmd = provider.CreateCommand())
                {
                    using (DbDataAdapter da = provider.CreateDataAdapter())
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        da.SelectCommand = cmd;
                        DataSet ds = new DataSet();
                        try
                        {
                            da.Fill(ds, "ds");
                            cmd.Parameters.Clear();
                            return ds.Tables[0];
                        }
                        catch (DbException ex)
                        {
                            connection.Close();
                            connection.Dispose();
                            throw new Exception(ex.Message);
                        }
                    }
                }
            }
        }

        private void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, string cmdText, DbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {
                foreach (DbParameter parm in cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
        }
    }
}

如有侵权请联系我删除。
结束！！！！！

大鹏一日通风起 扶摇直上九万里

魔王-T
关注
专栏目录
C# .Net 连接Oracle数据库DataHelPer 类型
吴立星的博客
06-05 577
要先下载对应的Oracle.manageddataAccess 的包引用，如果找不到也可以到这里下载。我的一个案例分析（https://download.csdn.net/download/wulixing/11227168） using System; using System.Collections; using System.Collections.Generic; using Syste...
DataHelper类
11-09
DataHelper类 通用的哦.支持sql server 以及oracle
C#，一份非常实用的DataHelper类
04-02
C#，一份非常实用的DataHelper类，自己收集了一年多的帮助类。，自己收集了一年多的帮助类。，自己收集了一年多的帮助类。
dataHelper
11-21
数据库连接，sql、Oracle、Access、Db、Mysql 连接数据的类
C#，DataHelper，一个通用的帮助类，留个备份。
axingm5214的博客
03-30 289
1 using System; 2 using Newtonsoft.Json; 3 using System.IO; 4 using System.Text; 5 6 namespace CarHailing.Base 7 { 8 /// <summary> 9 /// 数据帮助类 10 ...
DataHelper
04-12
一个完整的数据库操作对象类库,可以直接使用该对象以减少代码量,并且包括了SqlParameter防注入方法.
js代码-DataHelper
07-14
在JavaScript编程中，`DataHelper`通常是指一个辅助类或者模块，用于处理数据相关的操作。这个压缩包包含了一个名为`main.js`的主要脚本文件和一个`README.txt`的说明文件。在这里，我们将主要探讨`DataHelper`在...
C# 各种helper类
09-12
C#下的各种helper类的集合，放在一个可执行的vs项目里，具体有string,ftp,file,excel,md5,datatable,datareader,xml,enum等等
数据帮助类(DataHelper)
weixin_30814329的博客
04-15 445
/// <summary> /// 是否为空... /// </summary> /// <param name="str">数据值</param> /// <param name="typeName">数据类型</param> //...
DataHelper （转）
weixin_30780649的博客
11-05 125
1.建一个通用的处理数据的类 usingSystem; usingSystem.Data; usingSystem.Data.SqlClient; usingSystem.Text; namespaceDocument { /**////<summary> ///SummarydescriptionforDataHelper...
C#之DatabaseHelper
变是永远不变的......
02-05 4182
在C#最后的一个加密解密的实例中，说到了DatabaseHelper，DatabaseHelper是一种能连接4中数据库的DatabaseHelper类，也就是说在连接数据库时，你的数据库可能是SQL Server，可能是OLEDB或者其他的，为了让数据库连接，查询等不受影响，我们就需要这样一个中介可以连接不同的数据库——DatabaseHelper。下面是实战中DatabaseHelper的一段
一个C#针对Access的简单DataHelper
webdev2008的专栏
09-13 166
写个C#针对Access的简单DataHelper!! 但愿能够对大家有帮助   using System; using System.Data; using System.Configuration; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.WebC...
DataHelper 公共类
owner188的专栏
08-24 822
1.建一个通用的处理数据的类using System;using System.Data;using System.Data.SqlClient;using System.Text;namespace Document{    /**////     /// Summary description for DataHelper.    ///     public class DataHelper    {        public DataHelper()        {            // 
Oracle数据库BulkCopy高效批量插入示例
在.NET开发中，Oracle.DataAccess.Client库提供了OracleBulkCopy类，用于执行批量数据插入操作。这个类类似于SQL Server中的SqlBulkCopy，允许我们一次性传输大量数据行到目标表，大大减少了网络通信和数据库处理的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值