精华内容
下载资源
问答
  • 数据库帮助类

    2013-08-21 10:17:39
    DBHelp类,数据库帮助类
  • ado数据库帮助类

    2013-05-21 08:48:52
    ado 数据库帮助类 数据库帮助类 数据库帮助类
  • 数据库帮助类-无bug

    2016-09-26 13:24:30
    数据库帮助类-无bug
  • 本文实例讲述了C#操作SQLite数据库帮助类。分享给大家供大家参考,具体如下: 最近有WPF做客户端,需要离线操作存储数据,在项目中考虑使用Sqlite嵌入式数据库,在网上找了不少资料,最终整理出一个公共的帮助类。 ...
  • DBHelper 数据库帮助类

    2018-05-29 18:50:48
    重写了数据库连接,使用起来更加方便,快捷;具体使用方法看博客
  • SQLHelper 数据库帮助类,全部写好。注释详情
  • SQLlite数据库帮助类

    2018-12-13 13:30:29
    sqlite数据库常用工具:ExecuteDataSet、UpdateDataset等对比表的增删改查封装
  • 简单JAVA写的mysql数据库帮助类与测试示例 TestMySqlConn - 副本.java MySqlConn - 副本.java
  • MySQL数据库帮助类

    2019-03-22 13:20:55
    如果你使用的是MySQL数据库,你可以直接将文件添加到项目中使用
  • 数据库帮助类MySQLHelper 程序中我们可能经常会在某个语句或者某方法后去修改数据库的内容(增删查改的一系列操作),但如果我们直接在程序中写这部分的代码会使得我们的代码量很大,并且我们可能经常做这种重复的...

    数据库帮助类MySQLHelper

           程序中我们可能经常会在某个语句或者某方法后去修改数据库的内容(增删查改的一系列操作),但如果我们直接在程序中写这部分的代码会使得我们的代码量很大,并且我们可能经常做这种重复的操作,所有我们就把我们会用到的数据库操作封装起来放到一个类中,用的时候直接调用,方便编码和提高代码的可阅读性,这样我们就需要一个数据库帮助类。

    那我就直接上代码了,项目MySql.Data.dll程序集引用要记得加上,结合我之前写过的app.config配置文件那一篇博客可能更配哦(这个背景如果看着不习惯可以复制到自己新创建的项目中看

    ​
     class MySQLHelper
        {
            //数据库连接字符串(注意:这里的“MySQLDBConnectionString”一定要与App.config文件中connectionStrings节点值一致)(两种写法)
            //public static readonly string connectionString = ConfigurationManager.AppSettings["MySQLDBConnection"].ToString();
            public static readonly string connectionString = ConfigurationManager.ConnectionStrings["MySQLDBConnection"].ConnectionString;
    
            /// <summary>
            /// 给定连接的数据库用假设参数执行一个sql命令(非查询语句,不返回数据集)
            /// </summary>
            /// <param name="cmdText">要执行的sql语句</param>
            /// <param name="cmdType">命令类型(存储过程,文本等)</param>
            /// <param name="commandParmeters">执行命令所用的参数的集合</param>
            /// <returns>执行命令做影响的行数</returns>
            public static int ExcuteNonQuery(string cmdText, CommandType cmdType, params MySqlParameter[] commandParmeters)
            {
                //使用using 语句,方便using语句中声明的对象自动被Dispose
                using (MySqlCommand cmd = new MySqlCommand())
                {
                    using (MySqlConnection connection = new MySqlConnection(connectionString))
                    {
                        try
                        {
                            //执行命令前预处理
                            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParmeters);
                            //执行非查询操作
                            int val = cmd.ExecuteNonQuery();
                            //清空传入的参数
                            cmd.Parameters.Clear();
                            return val;
                        }
                        catch (Exception e)
                        {
                            throw new Exception(e.Message);
                        }
                    }
                }
            }
    
    
            /// <summary>
            /// 查询语句,返回查询到的int型数值
            /// </summary>
            /// <param name="cmdText">查询语句</param>
            /// <param name="cmdType">命令字符串类型</param>
            /// <param name="commandParameters">SQL语句对应参数</param>
            /// <returns>查询到的值</returns>
            public static int GetCount(string cmdText, CommandType cmdType = CommandType.Text, params MySqlParameter[] commandParameters)
            {
                //创建MySqlCommand执行命令语句对象
                using (MySqlCommand cmd = new MySqlCommand())
                {
                    //创建一个MySqlConnection对象
                    using (MySqlConnection con = new MySqlConnection())
                    {
                        try
                        {
                            //对MySqlCommand对象设置参数
                            PrepareCommand(cmd, con, null, cmdType, cmdText, commandParameters);
                            //创建一个适配器adapter
                            using (MySqlDataAdapter adapter = new MySqlDataAdapter())
                            {
                                //给适配器添加MySqlCommand执行命令语句对象
                                adapter.SelectCommand = cmd;
                                //定义一个结果数据集
                                DataSet ds = new DataSet();
                                //将查询到数据填充到数据集
                                adapter.Fill(ds);
                                //清空参数
                                cmd.Parameters.Clear();
                                DataTable dt = ds.Tables[0];
                                return Convert.ToInt32(dt.Rows[0][0]);
                                //return DataSetToList<T>(ds, 0);
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.GetType() + ":" + e.Message);
                            return -1;
                        }
                    }
                }
            }
    
    
            /// <summary>
            /// 执行查询语句返回List
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="cmdText">查询语句</param>
            /// <param name="cmdType">命令字符串类型</param>
            /// <param name="commandParameters">SQL语句对应参数</param>
            /// <returns>DataSet</returns>
            public static IList<T> GetList<T>(string cmdText, CommandType cmdType = CommandType.Text, params MySqlParameter[] commandParameters)
            {
                //创建MySqlCommand执行命令语句对象
                using (MySqlCommand cmd = new MySqlCommand())
                {
                    //创建一个MySqlConnection对象
                    using (MySqlConnection conn = new MySqlConnection(connectionString))
                    {
                        //在这里用一个try/catch结构执行sql文本命令/存储过程,因为如果这个方法产生一个异常我们要关闭连接,因为没有读取器存在
                        try
                        {
                            //调用PrepareCommand方法,对MySqlCommand对象设置参数
                            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
    
                            //声明一个适配器
                            using (MySqlDataAdapter adapter = new MySqlDataAdapter())
                            {
                                //给适配器添加MySqlCommand执行命令语句对象
                                adapter.SelectCommand = cmd;
    
                                //定义一个结果数据集
                                DataSet ds = new DataSet();
                                //将查询到数据填充到数据集
                                adapter.Fill(ds);
    
                                //清除参数
                                cmd.Parameters.Clear();
                                return DataSetToList<T>(ds, 0);
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.Message);
                            return null;
                        }
                    }
                }
            }
    
            /// <summary>
            /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列
            /// </summary>
            /// <remarks>
            ///例如: Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
            /// </remarks>
            /// <param name="cmdText">存储过程名称或者sql命令语句</param>
            /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
            /// <param name="commandParameters">执行命令所用参数的集合</param>
            /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
            public static object ExecuteScalar(string cmdText, CommandType cmdType, params MySqlParameter[] commandParameters)
            {
                //创建MySqlCommand执行命令语句对象
                using (MySqlCommand cmd = new MySqlCommand())
                {
                    //使用using语句,方便using语句中声明的对象自动被Dispose
                    using (MySqlConnection connection = new MySqlConnection(connectionString))
                    {
                        try
                        {
                            //执行命令前预处理
                            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
    
                            //使用ExecuteScalar()执行SQL语句,返回第一行第一列,object类型;转换使用Convert,不要使用强转;
                            //使用ExecuteScalar()一般执行聚合查询;使用ExecuteScalar()亦可查询select getdate()
                            object val = cmd.ExecuteScalar();
    
                            //清除参数
                            cmd.Parameters.Clear();
                            return val;
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.GetType() + ":" + e.Message);
                            return null;
                        }
                    }
                }
            }
    
            /// <summary>
            /// 执行多条SQL语句,实现数据库事务。
            /// </summary>
            /// <param name="sqlStringList">多条SQL语句</param>
            /// <param name="commandParametersList">对应SQL语句列表中每一条语句的参数集合列表</param>
            /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
            public static void ExecuteBatchSql(IList<string> sqlStringList, IList<MySqlParameter[]> commandParametersList, CommandType cmdType = CommandType.Text)
            {
                if (sqlStringList.Count == 0 || commandParametersList.Count == 0 || sqlStringList.Count != commandParametersList.Count)
                {
                    throw new Exception("传入参数错误");
                }
    
                //创建MySqlCommand执行命令语句对象
                using (MySqlCommand cmd = new MySqlCommand())
                {
                    //使用using语句,方便using语句中声明的对象自动被Dispose
                    using (MySqlConnection conn = new MySqlConnection(connectionString))
                    {
                        //打开数据库连接
                        conn.Open();
                        //MySqlCommand执行命令语句对象添加数据库连接对象
                        cmd.Connection = conn;
                        //创建事务
                        MySqlTransaction tx = conn.BeginTransaction();
                        //MySqlCommand执行命令语句对象添加事务对象
                        cmd.Transaction = tx;
                        try
                        {
                            //遍历SQL语句,依次执行
                            for (int n = 0; n < sqlStringList.Count; n++)
                            {
                                //执行命令前预处理
                                PrepareCommand(cmd, conn, null, cmdType, sqlStringList[n], commandParametersList[n]);
                                //执行非查询数据库操作
                                cmd.ExecuteNonQuery();
                                //清空传入的参数
                                cmd.Parameters.Clear();
                            }
    
                            //一次性提交事务
                            tx.Commit();
                        }
                        catch (System.Data.SqlClient.SqlException e)
                        {
                            tx.Rollback();
                            Console.WriteLine(e.GetType() + ":" + e.Message);
                            throw new Exception(e.Message);
                        }
                    }
    
                }
            }
    
    
            /// <summary>
            /// 返回DataSet
            /// </summary>
            /// <param name="cmdText">存储过程名称或者sql命令语句</param>
            /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
            /// <param name="commandParameters">执行命令所用参数的集合</param>
            /// <returns>结果数据集</returns>
            public static DataSet GetDataSet(string cmdText, CommandType cmdType = CommandType.Text, params MySqlParameter[] commandParameters)
            {
                //创建一个MySqlCommand对象
                MySqlCommand cmd = new MySqlCommand();
                //创建一个MySqlConnection对象
                MySqlConnection conn = new MySqlConnection(connectionString);
    
                //在这里用一个try/catch结构执行sql文本命令/存储过程,因为如果这个方法产生一个异常我们要关闭连接,因为没有读取器存在
                try
                {
                    //调用PrepareCommand方法,对MySqlCommand对象设置参数
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
    
                    //声明一个适配器
                    MySqlDataAdapter adapter = new MySqlDataAdapter();
                    //给适配器添加MySqlCommand执行命令语句对象
                    adapter.SelectCommand = cmd;
    
                    //定义一个结果数据集
                    DataSet ds = new DataSet();
                    //将查询到数据填充到数据集
                    adapter.Fill(ds);
    
                    //清除参数
                    cmd.Parameters.Clear();
    
                    //关闭数据库连接对象
                    conn.Close();
                    return ds;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.GetType() + ":" + e.Message);
                    //throw e;
                }
                return null;
            }
    
    
            /// <summary>
            /// 用执行的数据库连接执行一个返回数据集的sql命令
            /// </summary>
            /// <remarks>
            /// 举例:
            ///  MySqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
            /// </remarks>
            /// <param name="cmdText">存储过程名称或者sql命令语句</param>
            /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
            /// <param name="commandParameters">执行命令所用参数的集合</param>
            /// <returns>包含结果的读取器</returns>
            public static MySqlDataReader ExecuteReader(string cmdText, CommandType cmdType = CommandType.Text, params MySqlParameter[] commandParameters)
            {
                //创建一个MySqlCommand对象
                MySqlCommand cmd = new MySqlCommand();
                //创建一个MySqlConnection对象
                MySqlConnection conn = new MySqlConnection(connectionString);
    
                //在这里用一个try/catch结构执行sql文本命令/存储过程,因为如果这个方法产生一个异常我们要关闭连接,因为没有读取器存在,
                //因此commandBehaviour.CloseConnection 就不会执行
                try
                {
                    //调用 PrepareCommand 方法,对 MySqlCommand 对象设置参数
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
    
                    //调用MySqlCommand 的ExecuteReader方法
                    //CommandBehavior.CloseConnection的功能是保证当MySqlDataReader对象被关闭时,其依赖的连接也会被自动关闭
                    MySqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    //清除参数
                    cmd.Parameters.Clear();
                    return reader;
                }
                catch (Exception e)
                {
                    //关闭连接,抛出异常
                    conn.Close();
    
                    Console.WriteLine(e.GetType() + ":" + e.Message);
                    //throw;
                }
                return null;
            }
    
            /// <summary>
            /// 执行命令前预处理
            /// </summary>
            /// <param name="cmd">MySqlCommand执行命令语句对象</param>
            /// <param name="con">数据库连接对象</param>
            /// <param name="trans">事务</param>
            /// <param name="cmdType">命令类型例如 存储过程或者文本</param>
            /// <param name="cmdText">命令文本,例如:Select * from Products</param>
            /// <param name="cmdParms">执行命令的参数</param>
            private static void PrepareCommand(MySqlCommand cmd, MySqlConnection con, MySqlTransaction trans, CommandType cmdType, string cmdText, MySqlParameter[] cmdPrams)
            {
                //判断数据连接状态是否是打开状态
                if (con.State != ConnectionState.Open)
                    con.Open();
    
                //给执行命令语句的对象添加数据库连接对象
                cmd.Connection = con;
                //给执行命令语句的对象添加命令文本
                cmd.CommandText = cmdText;
                //给执行命令语句的对象添加命令类型
                cmd.CommandType = cmdType;
    
                //判断事物是否为空
                if (trans != null)
                    cmd.Transaction = null;
                //判断执行命令的参数是否为空
                if (cmdPrams != null)
                {
                    foreach (MySqlParameter parameter in cmdPrams)
                    {
                        //将参数添加到执行命令语句的对象的参数集合中
                        cmd.Parameters.Add(parameter);
                    }
                }
    
            }
    
    
            /// <summary>
            /// DataSet数据转为IList集合
            /// </summary>
            /// <typeparam name="T">转换类型</typeparam>
            /// <param name="dataSet">数据源</param>
            /// <param name="tableIndex">需要转换表的索引</param>
            /// <returns></returns>
            public static IList<T> DataSetToList<T>(DataSet dataSet, int tableIndex)
            {
                //确认参数是否有效
                if (dataSet == null || dataSet.Tables.Count <= 0 || tableIndex < 0)
                    return null;
                //声明DataTable对象,通过索引来获取数据集DataSet中指定表
                DataTable dt = dataSet.Tables[tableIndex];
                //声明用于返回的集合对象
                IList<T> list = new List<T>();
                //遍历datatable中每一行数据
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    //创建泛型对象
                    T _t = Activator.CreateInstance<T>();
                    //获取对象所有属性
                    PropertyInfo[] propertyInfo = _t.GetType().GetProperties();
    
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        foreach (PropertyInfo info in propertyInfo)
                        {
                            //属性名称和列名称相同时赋值
                            if (dt.Columns[j].ColumnName.ToUpper().Equals(info.Name.ToUpper()))
                            {
                                //判断是否为空
                                if (dt.Rows[i][j] != DBNull.Value)
                                {
                                    //不为空设置当前列值
                                    info.SetValue(_t, dt.Rows[i][j], null);
                                }
                                else
                                {
                                    //为空,设为null
                                    info.SetValue(_t, null, null);
                                }
                                break;
                            }
                        }
                    }
                    list.Add(_t);
                }
                return list;
            }
    
        }
    
    ​

     

    展开全文
  • 韩顺平 php 数据库帮助类 使用方法: $sql='select*from minke_info'; SqlHelper sqlHelper=new SqlHelp(); $res=sqlHelp->execute_dql($sql); print_r(res); ?>
  • c#语言,操作 DB2数据库帮助类,以及包含IBM.Data.DB2.DLL,网上找了好多dll都不能用,希望这个资源能够帮助需要用的小伙伴哦
  • 鄙人有空之时,写了一个简单的操作SQL数据库帮助类,大家有什么意见,希望能沟通一下
  • ADO.NET 封装的数据库帮助类

    千次阅读 2017-03-29 23:34:51
    C# ADO.NET封装的数据库帮助类
    using System;
    using System.Data;
    using System.Configuration;
    using System.Data.SqlClient;
    
    namespace DAL
    {
        /// <summary>
        /// 数据库帮助类
        /// </summary>
        public abstract class DatabaseHelper
        {
            # region 成员变量
    
            /// <summary>
            /// 数据库连接字符串
            /// </summary>
            private static string m_ConnectionString = null;
    
            # endregion
    
            # region 属性
    
            /// <summary>
            /// 获取数据库连接字符串
            /// </summary>
            /// <returns></returns>
            public string ConnectionString
            {
                get
                {
                    if (m_ConnectionString == null)
                    {
                        m_ConnectionString = ReadConnectionString("ConnectionString");
                    }
    
                    return m_ConnectionString;
                }
            }
    
            # endregion
    
            # region 构造函数
    
            public DatabaseHelper()
            {
                m_ConnectionString = ReadConnectionString("ConnectionString");
            }
    
            public DatabaseHelper(string connectionString)
            {
                m_ConnectionString = connectionString;
            }
    
            # endregion
    
            # region 静态方法
    
            /// <summary>
            /// 从配置文件读取数据库连接字符串
            /// </summary>
            /// <param name="configKeyName"></param>
            /// <returns></returns>
            private static string ReadConnectionString(string configKeyName)
            {
                string connectionString = "";
    
                object obj = ConfigurationManager.ConnectionStrings[configKeyName];
                if (obj != null)
                {
                    connectionString = obj.ToString();
                }
    
                return connectionString;
            }
    
            /// <summary>
            /// 获取数据库连接字符串
            /// </summary>
            /// <returns></returns>
            public static string GetConnectionString()
            {
                if (m_ConnectionString == null)
                {
                    m_ConnectionString = ReadConnectionString("ConnectionString");
                }
    
                return m_ConnectionString;
            }
    
            #endregion
    
            #region 抽象方法
    
            protected abstract object DataReaderToEntity(IDataReader dataReader);
    
            #endregion
    
            #region 数据库操作方法
    
            /// <summary>
            /// 构造数据库操作命令
            /// </summary>
            /// <param name="conn">数据库连接对象</param>
            /// <param name="cmdString">sql语句</param>
            private SqlCommand CreateCommand(SqlConnection conn, string cmdString)
            {
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = cmdString;
    
                return cmd;
            }
    
            /// <summary>
            /// 清空参数,释放SqlCommand资源
            /// </summary>
            /// <param name="cmd"></param>
            private void DisposeCommand(SqlCommand cmd)
            {
                if (cmd != null)
                {
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                }
            }
    
            /// <summary>
            /// 绑定SqlCommand参数,参数值为空时不添加
            /// </summary>
            /// <param name="cmd"></param>
            /// <param name="parameters"></param>
            private void AttachParameters(SqlCommand cmd, params SqlParameter[] parameters)
            {
                if (parameters != null)
                {
                    foreach (SqlParameter para in parameters)
                    {
                        if (para != null)
                        {
                            if (para.Direction == ParameterDirection.InputOutput ||
                                (para.Direction == ParameterDirection.Input && para.Value == null))
                            {
                                para.Value = DBNull.Value;
                            }
                            cmd.Parameters.Add(para);
                        }
                    }
                }
            }
    
            /// <summary>
            /// 执行一个查询,返回查询的结果集
            /// </summary>
            /// <param name="sqlString">sql语句</param>
            /// <param name="parameters">参数化参数</param>
            /// <returns>查询的结果集</returns>
            public DataTable ExecuteDataTable(string sqlString, params SqlParameter[] parameters)
            {
                DataTable dataTable = new DataTable();
    
                using (SqlConnection conn = new SqlConnection(m_ConnectionString))
                {
                    conn.Open();
    
                    SqlCommand cmd = CreateCommand(conn, sqlString);
                    AttachParameters(cmd, parameters);
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    adapter.Fill(dataTable);
    
                    DisposeCommand(cmd);
                }
    
                return dataTable;
            }
    
            /// <summary>
            /// 执行sql操作,返回受影响的行数
            /// </summary>
            /// <param name="sqlString">sql语句</param>
            /// <param name="parameters">参数化参数</param>
            /// <returns>受影响的行数</returns>
            public int ExecuteNonQuery(string sqlString, params SqlParameter[] parameters)
            {
                int num = 0;
    
                using (SqlConnection conn = new SqlConnection(m_ConnectionString))
                {
                    conn.Open();
    
                    SqlCommand cmd = CreateCommand(conn, sqlString);
                    AttachParameters(cmd, parameters);
                    num = cmd.ExecuteNonQuery();
                    DisposeCommand(cmd);
                }
    
                return num;
            }
    
            /// <summary>
            /// 执行查询,并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。
            /// </summary>
            /// <param name="sqlString">sql语句</param>
            /// <param name="parameters">参数化参数</param>
            /// <returns>结果集中第一行的第一列;如果结果集为空,则为空引用</returns>
            public object ExecuteScalar(string sqlString, params SqlParameter[] parameters)
            {
                object obj = new object();
    
                using (SqlConnection conn = new SqlConnection(m_ConnectionString))
                {
                    conn.Open();
    
                    SqlCommand cmd = CreateCommand(conn, sqlString);
                    AttachParameters(cmd, parameters);
                    obj = cmd.ExecuteScalar();
                    DisposeCommand(cmd);
                }
    
                return obj;
            }
    
            public SqlDataReader ExecuteReader(string sqlString, params SqlParameter[] parameters)
            {
                SqlDataReader reader = null;
    
                SqlConnection conn = new SqlConnection(m_ConnectionString);
                conn.Open();
                SqlCommand cmd = CreateCommand(conn, sqlString);
                AttachParameters(cmd, parameters);
                reader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
                DisposeCommand(cmd);
    
                return reader;
            }
    
            # endregion
        }
    }
    
    展开全文
  • 不管什么项目基本都不能避免对频繁的对数据库进行操作。如果直接在代码中操作,不仅会... 这时我们可以把相对应的,需要大量重复使用的代码封装到一个帮助类里--数据库帮助类。在这个类里,我们只需要实例化一次Sql...

            不管什么项目基本都不能避免对频繁的对数据库进行操作。如果直接在代码中操作,不仅会导致代码里面夹杂着太多的SQL语句,影响代码的可读性,还会因为创建太多变量影响程序运行性能。基于MVC编程思想,对数据库的操作应该与控制逻辑的代码分离。

             这时我们可以把相对应的,需要大量重复使用的代码封装到一个帮助类里--数据库帮助类。在这个类里,我们只需要实例化一次SqlConnection,就可以在程序关闭前重复使用该类里面的所有方法。

      

    /// <summary>
       /// 数据库帮助类
       /// </summary>
       public class SqlHelpClass
        {
            static private string strServer;//数据库服务器地址,就是计算机名称
            static private string strUid;//SQLserver用户名称
            static private string strPwd;//密码
            static private string strDatabaseName;//数据库名称
    
            //属性限制外部只能设置数据库的链接信息
            static public string StrServer { set => strServer = value; }
            static public string StrUid { set => strUid = value; }
            static public string StrPwd { set => strPwd = value; }
            static public string StrDatabaseName { set => strDatabaseName = value; }
           
            static public string strSql
            {
                //这个字符串是连接字符串,包含着数据库的信息,对外部只提供信息不能修改
                get
                {
                  return   strServer + ";" + strUid + ";" + strPwd + ";" + strDatabaseName;
                }
            }
            static SqlConnection sqlConnection;
            static SqlCommand cmd;
    
            static SqlHelpClass()
            {
                //静态构造函数,如果你需要给数据库信息设置默认值
                strServer = "";
                strUid = "";
                strPwd = "";
                strDatabaseName = "";
            }
    
            /// <summary>
            /// 返回一个数据库连接
            /// </summary>
            /// <returns></returns>
            public static SqlConnection GetSqlConnection()
            {
                
                sqlConnection = new SqlConnection();
                sqlConnection.ConnectionString = strSql;
                return sqlConnection;
            }
    
    
    
            #region 对连接执行SQL语句或存储过程并返回受影响行数
            /// <summary>
            /// 对连接执行SQL语句并返回受影响行数
            /// </summary>
            /// <param name="sql">数据库操作命令语句</param>
            /// <returns>受影响的行数</returns>
            private static int ExecuteNonQueryTypeText(string sql)
            {
    
                sqlConnection = new SqlConnection();//创建一个数据库连接实例(实例就是对象)
                                                    //对这个类SqlConnection作用不明白的可以把鼠标放到类名可以显示微软对类给出的说明
    
                try
                {
                    sqlConnection.ConnectionString = strSql;//数据库的信息给到这个连接,
                   
                    sqlConnection.Open();//打开连接
    
                    cmd = new SqlCommand();/*创建一个查询实例
                                             *SqlConnection就像路,我们创建SqlConnection实例时就打通了连通数据库的一条路
                                             *SqlCommand就是信使,
                                             *我们每次要对数据库发出指令时,SqlCommand对象就可以帮我们把这个指令送到数据库
                                             * 数据库处理完后,再通过SqlCommand把我们需要的数据传回来。*/
    
                    cmd.CommandText = sql;//设置要执行的数据库命令,就是你得把信给信使
    
                    cmd.Connection = sqlConnection;//设置查询
    
                    return cmd.ExecuteNonQuery();//返回受影响的行数,cmd.ExecuteNonQuery()在这里相当于执行命令:你给我把信送过去。
                                                 //如果没有cmd.ExecuteNonQuery(),那么命令是不会执行的。
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
                    //如果不想抛出异常影响程序进行,这里可以不写
                    //或者返回个-1,然后在使用类里做判断
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
                                          //数据库连接一般都是一次查询打开一个连接,查询结束关闭当前连接。
                                          //都已经把主要代码写在帮助类里了就不要想着强行省代码,该写的还得写
                                          //不要想着一个SqlConnection多次共用,防止出现不必要的异常或错误
                                          
                }
    
            }
    
            /// <summary>
            /// 对连接执行有参数的数据库的存储过程并返回受影响行数
            /// </summary>
            /// <param name="StoredProcedureName">数据库的存储过程的名称</param>
            /// <param name="sqlParameters">SqlParameter集合</param>
            /// <returns>受影响行数</returns>
            private static int ExecuteNonQueryTypeStoredProcedure(string StoredProcedureName, SqlParameter[] sqlParameters)
            {
                /*SqlParameter:
                 *例: SqlParameter("@ID",ID)
                 * @ID:就是数据库存储过程的参数
                 * ID:就是你给这个参数赋的值
                 * 
                 * 要执行存储过程,首先就要给存储过程里边的参数赋值,
                 * 一个SqlParameter可以给一个参数赋值,
                 * 而一个SqlParameter数组可以包含给所有参数赋值的SqlParameter
                 */
                sqlConnection = new SqlConnection();
                try
                {
                    sqlConnection.ConnectionString = strSql;//数据库的信息给到这个连接,
    
                    sqlConnection.Open();//打开连接
                    cmd = new SqlCommand();//创建一个查询实例
                    cmd.CommandType = CommandType.StoredProcedure;//设置cmd的行为类型
                    cmd.CommandText = StoredProcedureName;//设置要执行的数据库存储过程的名称
                    cmd.Connection = sqlConnection;//设置连接
                    cmd.Parameters.AddRange(sqlParameters);//AddRange方法给cmd的参数添加sqlParameters集合
                    return cmd.ExecuteNonQuery();//返回结果
    
    
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
    
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
    
                }
            }
    
            /// <summary>
            /// 连接执行无参数的数据库的存储过程并返回受影响行数
            /// </summary>
            /// <param name="StoredProcedureName">数据库的存储过程的名称</param>
            /// <returns>受影响行数</returns>
            private static int ExecuteNonQueryTypeStoredProcedure(string StoredProcedureName)
            {
                sqlConnection = new SqlConnection();
                try
                {
                    sqlConnection.ConnectionString = strSql;//数据库的信息给到这个连接,
    
                    sqlConnection.Open();//打开连接
                    cmd = new SqlCommand();//创建一个查询实例
                    cmd.CommandType = CommandType.StoredProcedure;//设置cmd的行为类型
                    cmd.CommandText = StoredProcedureName;//设置要执行的数据库存储过程的名称
                    cmd.Connection = sqlConnection;//设置连接
                   
                    return cmd.ExecuteNonQuery();//返回结果
    
    
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
    
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
    
                }
            }
    
            /// <summary>
            /// 对连接执行SQL语句或无参数存储过程并返回受影响行数
            /// </summary>
            /// <param name="sqlOrSPname">SQL语句或者无参数存储过程名称</param>
            /// <param name="commandType">解释命令字符串类型</param>
            /// <returns></returns>
            public static int ExecuteNonQuery(string sqlOrSPname, CommandType commandType)
            {
                switch (commandType)
                {
                    case CommandType.StoredProcedure:
                      return  ExecuteNonQueryTypeStoredProcedure(sqlOrSPname);
                        
                    case CommandType.Text:
                       return ExecuteNonQueryTypeText(sqlOrSPname);
                       
                    default:                   
                        return ExecuteNonQueryTypeText("select * from "+ sqlOrSPname);
    
                }
               
            }
            /// <summary>
            /// 连接执行有参数存储过程并返回受影响行数
            /// </summary>
            /// <param name="sqlOrSPname">有参数存储过程名称</param>
            /// <param name="sqlParameters">SqlParametes数组</param>
            /// <returns></returns>
            public static int ExecuteNonQuery(string sqlOrSPname, SqlParameter[] sqlParameters)
            {
                return ExecuteNonQueryTypeStoredProcedure(sqlOrSPname, sqlParameters);
            }
            #endregion
    
    
            /// <summary>
            /// 返回查询结果集的第一行第一列的值
            /// </summary>
            /// <returns>查询结果第一行第一列的值</returns>
            public static object ExecuteScalar(string sql)
            {
                sqlConnection = new SqlConnection();
                try               
                {
                    sqlConnection.ConnectionString = strSql;//数据库的信息给到这个连接,
    
                    sqlConnection.Open();//打开连接
                    cmd = new SqlCommand();//创建一个查询实例
                            
                    cmd.CommandText = sql.ToString();//设置要执行的数据库命令
                    cmd.Connection = sqlConnection;//设置查询
                   
                    return cmd.ExecuteScalar();//返回结果
    
    
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
                    
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
                                         
                }
               
            }
    
            #region 查询数据库返回一个DataTable
            /// <summary>
            /// 查询数据库表返回一个只读结果集
            /// </summary>
            /// <param name="sql">查询语句</param>
            /// <returns>DataTable</returns>
            public DataTable GetReadOnlyDataTable(string sql)
            {
                sqlConnection = new SqlConnection();
                try
                {
                    sqlConnection.ConnectionString = strSql;
                    cmd = new SqlCommand(sql, sqlConnection);//利用SqlCommand构造函数的重载,可以在实例化时就给相对应得属性赋值
                    SqlDataReader reader = cmd.ExecuteReader();//根据sql读取数据库表,返回一个只读结果集
                    DataTable dt = new DataTable();//创建一个DataTable对象
                    dt.Load(reader);//将读到的结果集填充到DataTable对象    
                    return dt;
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
    
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
    
                }
            }
            /// <summary>
            /// 查询数据库表返回一个可读写可操作的结果集
            /// </summary>
            /// <param name="sql"></param>
            /// <returns></returns>
            public DataTable GetReadWwriteDataTable(string sql)
            {
                sqlConnection = new SqlConnection();
                try
                {
                    sqlConnection.ConnectionString = strSql;
                   
                    SqlDataAdapter adapter =new SqlDataAdapter(sql, sqlConnection);//返回一个可读写可操作的结果集
                    DataTable dt = new DataTable();//创建一个DataTable对象
                    adapter.Fill(dt);//将结果集填充到DataTable对象 
                    return dt;
                }
                catch (Exception e)
                {
    
                    throw e;//抛出异常
    
                }
                finally
                {
                    sqlConnection.Close();//关闭数据库连接
    
                }
            }
            #endregion
    
          
    
    
    
    
          
        }

        静态构造函数:初始化类的静态数据成员

                                  仅在类被加载时执行一次

                                   不允许使用访问修饰符

      写在静态构造函数里,只要在其他类里出现SqlHelpClass,数据库帮助类类名,那么SqlHelpClass就算被加载了,不需要实例化就创建好了对数据库的连接。而里面的方法都是静态方法,全部都可以类名点方法名(例:SqlHelpClass.ExecuteNonQuery())就可以实用,重头到尾都不需要实例化SqlHelpClass。

    可以在静态构造函数里给字段赋默认值。

    还有一点要注意的是:sqlconnection对象一般都是当次使用,使用完然后关闭。

    转载于:https://www.cnblogs.com/xwzLoveCshap/p/11540788.html

    展开全文
  • 连接Oracle数据库帮助类,就是把连接Oracle数据库的方法封装起来,只需要在其它页面调用就可,不需要重复写。 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; ...

    连接Oracle数据库帮助类,就是把连接Oracle数据库的方法封装起来,只需要在其它页面调用就可,不需要重复写。

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    import oracle.jdbc.driver.OracleDriver;
    
    /**
     * 数据库连接帮助类
     * @author zql_pc
     *
     */
    public class DbHelp {
    
        /*
         * 数据库连接
         */
        public static Connection lianjie(){
            
            //数据库配置
            String driver = "oracle.jdbc.driver.OracleDriver";//驱动
            String url = "jdbc:oracle:thin:@localhost:1521:JBITDB";
            String user = "epet";
            String pwd = "123456";
            
            try {
                //第一步:加载驱动
                Class.forName(driver);// -->反射
                
                Connection conn = DriverManager.getConnection(url,user,pwd);
                
                return conn;
                
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
              return null;
     }
    }

     

    转载于:https://www.cnblogs.com/wlx520/p/4501808.html

    展开全文
  • 使用前面所创建的银行ATM机系统 ... /// 数据库帮助类(使用工具类),里面的内容最好写成静态的 /// 也有的程序员会写成SQLHelper /// </summary> public static class DBHelper { private sta

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,647
精华内容 2,658
关键字:

数据库帮助类