两个数据库操作类

AccessHelper.cs

  1/**//// <summary>
  2/// AcceHelper 的摘要说明
  3/// </summary>
  4public static class AccessHelper
  5{
  6    //数据库连接字符串
  7    public static readonly string conn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + HttpContext.Current.Request.PhysicalApplicationPath + "App_Data\\" + Properties.Settings.Default.DbName;
  8    --执行ExecuteNonQuery--#region --执行ExecuteNonQuery--
  9    /**//// <summary>
 10    ///  给定连接的数据库用假设参数执行一个sql命令（不返回数据集）
 11    /// </summary>
 12    /// <param name="connectionString">一个有效的连接字符串</param>
 13    /// <param name="commandText">存储过程名称或者sql命令语句</param>
 14    /// <param name="commandParameters">执行命令所用参数的集合</param>
 15    /// <returns>执行命令所影响的行数</returns>
 16    public static int ExecuteNonQuery(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
 17    {
 18        OleDbCommand cmd = new OleDbCommand();
 19        using (OleDbConnection conn = new OleDbConnection(connectionString))
 20        {
 21            PrepareCommand(cmd, conn, null, cmdText, commandParameters);
 22            int val = cmd.ExecuteNonQuery();
 23            cmd.Parameters.Clear();
 24            return val;
 25        }
 26    }
 27    /**//// <summary>
 28    /// 用现有的数据库连接执行一个sql命令（不返回数据集）
 29    /// </summary>
 30    /// <remarks>
 31    ///举例:  
 32    ///  int result = ExecuteNonQuery(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
 33    /// </remarks>
 34    /// <param name="conn">一个现有的数据库连接</param>
 35    /// <param name="commandText">存储过程名称或者sql命令语句</param>
 36    /// <param name="commandParameters">执行命令所用参数的集合</param>
 37    /// <returns>执行命令所影响的行数</returns>
 38    public static int ExecuteNonQuery(OleDbConnection connection, string cmdText, params OleDbParameter[] commandParameters)
 39    {
 40        OleDbCommand cmd = new OleDbCommand();
 41        PrepareCommand(cmd, connection, null, cmdText, commandParameters);
 42        int val = cmd.ExecuteNonQuery();
 43        cmd.Parameters.Clear();
 44        return val;
 45    }
 46    /**//// <summary>
 47    ///使用现有的SQL事务执行一个sql命令（不返回数据集）
 48    /// </summary>
 49    /// <remarks>
 50    ///举例:  
 51    ///  int result = ExecuteNonQuery(trans, "PublishOrders", new OleDbParameter("@prodid", 24));
 52    /// </remarks>
 53    /// <param name="trans">一个现有的事务</param>
 54    /// <param name="commandText">存储过程名称或者sql命令语句</param>
 55    /// <param name="commandParameters">执行命令所用参数的集合</param>
 56    /// <returns>执行命令所影响的行数</returns>
 57    public static int ExecuteNonQuery(OleDbTransaction trans, string cmdText, params OleDbParameter[] commandParameters)
 58    {
 59        OleDbCommand cmd = new OleDbCommand();
 60        PrepareCommand(cmd, trans.Connection, trans, cmdText, commandParameters);
 61        int val = cmd.ExecuteNonQuery();
 62        cmd.Parameters.Clear();
 63        return val;
 64    }
 65    #endregion
 66    --执行查询--#region --执行查询--
 67    /**//// <summary>
 68    /// 用执行的数据库连接执行一个返回数据集的sql命令
 69    /// </summary>
 70    /// <remarks>
 71    /// 举例:  
 72    ///  OleDbDataReader r = ExecuteReader(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
 73    /// </remarks>
 74    /// <param name="connectionString">一个有效的连接字符串</param>
 75    /// <param name="commandText">存储过程名称或者sql命令语句</param>
 76    /// <param name="commandParameters">执行命令所用参数的集合</param>
 77    /// <returns>包含结果的读取器</returns>
 78    public static OleDbDataReader ExecuteReader(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
 79    {
 80        //创建一个SqlCommand对象
 81        OleDbCommand cmd = new OleDbCommand();
 82        //创建一个SqlConnection对象
 83        OleDbConnection conn = new OleDbConnection(connectionString);
 84        //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在，
 85        //因此commandBehaviour.CloseConnection 就不会执行
 86        try
 87        {
 88            //调用 PrepareCommand 方法，对 SqlCommand 对象设置参数
 89            PrepareCommand(cmd, conn, null, cmdText, commandParameters);
 90            //调用 SqlCommand  的 ExecuteReader 方法
 91            OleDbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
 92            //清除参数
 93            cmd.Parameters.Clear();
 94            return reader;
 95        }
 96        catch
 97        {
 98            //关闭连接，抛出异常
 99            conn.Close();
100            throw;
101        }
102    }
103    /**//// <summary>
104    /// 返回一个DataSet数据集
105    /// </summary>
106    /// <param name="connectionString">一个有效的连接字符串</param>
107    /// <param name="cmdText">存储过程名称或者sql命令语句</param>
108    /// <param name="commandParameters">执行命令所用参数的集合</param>
109    /// <returns>包含结果的数据集</returns>
110    public static DataSet ExecuteDataSet(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
111    {
112        //创建一个SqlCommand对象，并对其进行初始化
113        OleDbCommand cmd = new OleDbCommand();
114        using (OleDbConnection conn = new OleDbConnection(connectionString))
115        {
116            PrepareCommand(cmd, conn, null, cmdText, commandParameters);
117            //创建SqlDataAdapter对象以及DataSet
118            OleDbDataAdapter da = new OleDbDataAdapter(cmd);
119            DataSet ds = new DataSet();
120            try
121            {
122                //填充ds
123                da.Fill(ds);
124                // 清除cmd的参数集合 
125                cmd.Parameters.Clear();
126                //返回ds
127                return ds;
128            }
129            catch
130            {
131                //关闭连接，抛出异常
132                conn.Close();
133                throw;
134            }
135        }
136    }
137    #endregion
138    --执行ExecuteScalar--#region --执行ExecuteScalar--
139    /**//// <summary>
140    /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列
141    /// </summary>
142    /// <remarks>
143    ///例如:  
144    ///  Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
145    /// </remarks>
146    ///<param name="connectionString">一个有效的连接字符串</param>
147    /// <param name="commandText">存储过程名称或者sql命令语句</param>
148    /// <param name="commandParameters">执行命令所用参数的集合</param>
149    /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
150    public static object ExecuteScalar(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
151    {
152        OleDbCommand cmd = new OleDbCommand();
153        using (OleDbConnection connection = new OleDbConnection(connectionString))
154        {
155            PrepareCommand(cmd, connection, null, cmdText, commandParameters);
156            object val = cmd.ExecuteScalar();
157            cmd.Parameters.Clear();
158            return val;
159        }
160    }
161    /**//// <summary>
162    /// 用指定的数据库连接执行一个命令并返回一个数据集的第一列
163    /// </summary>
164    /// <remarks>
165    /// 例如:  
166    ///  Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
167    /// </remarks>
168    /// <param name="conn">一个存在的数据库连接</param>
169    /// <param name="commandText">存储过程名称或者sql命令语句</param>
170    /// <param name="commandParameters">执行命令所用参数的集合</param>
171    /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
172    public static object ExecuteScalar(OleDbConnection connection, string cmdText, params OleDbParameter[] commandParameters)
173    {
174        OleDbCommand cmd = new OleDbCommand();
175        PrepareCommand(cmd, connection, null, cmdText, commandParameters);
176        object val = cmd.ExecuteScalar();
177        cmd.Parameters.Clear();
178        return val;
179    }
180    #endregion
181    --准备执行一个命令--#region --准备执行一个命令--
182    /**//// <summary>
183    /// 准备执行一个命令
184    /// </summary>
185    /// <param name="cmd">sql命令</param>
186    /// <param name="conn">Sql连接</param>
187    /// <param name="trans">Sql事务</param>
188    /// <param name="cmdText">命令文本,例如：Select * from Products</param>
189    /// <param name="cmdParms">执行命令的参数</param>
190    private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] cmdParms)
191    {
192        //判断连接的状态。如果是关闭状态，则打开
193        if (conn.State != ConnectionState.Open)
194            conn.Open();
195        //cmd属性赋值
196        cmd.Connection = conn;
197        cmd.CommandText = cmdText;
198        //是否需要用到事务处理
199        if (trans != null)
200            cmd.Transaction = trans;
201        cmd.CommandType = CommandType.Text;
202        //添加cmd需要的存储过程参数
203        if (cmdParms != null)
204        {
205            foreach (OleDbParameter parm in cmdParms)
206                cmd.Parameters.Add(parm);
207        }
208    }
209    #endregion
210}

 

 

SqlHelper.cs

  1using System;
  2using System.Data;
  3using System.Data.SqlClient;
  4using System.Collections.Generic;
  5using System.Configuration;
  6using System.Linq;
  7using System.Text;
  8using System.Xml;
  9
 10/**//// <summary>
 11/// 数据库操作业务类
 12/// </summary>
 13public static class SqlHelper
 14{
 15    //获取配置文件的字符串
 16    public static string strConstring = Properties.Settings.Default.ConnStr;
 17    -执行查询-#region -执行查询-
 18    /**//// <summary>
 19    /// 执行查询
 20    /// </summary>
 21    /// <param name="connectionString">连接字符串</param>
 22    /// <param name="cmdType">sql数据库执行的类型</param>
 23    /// <param name="cmdText">sql数据库执行的文本</param>
 24    /// <param name="commandParameters">参数列表</param>
 25    /// <returns>返回查询结果</returns>
 26    public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
 27    {
 28        SqlCommand cmd = new SqlCommand();
 29        SqlConnection conn = new SqlConnection(connectionString);
 30        try
 31        {
 32            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
 33            SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
 34            cmd.Parameters.Clear();
 35            return rdr;
 36        }
 37        catch
 38        {
 39            conn.Close();
 40            throw;
 41        }
 42    }
 43    /**//// <summary>
 44    /// 执行查询
 45    /// </summary>
 46    /// <param name="connectionString">连接字符串</param>
 47    /// <param name="cmdType">sql数据库执行的类型</param>
 48    /// <param name="cmdText">sql数据库执行的文本</param>
 49    /// <param name="commandParameters">参数列表</param>
 50    /// <returns>返回查询结果</returns>
 51    public static DataTable ExecuteDataTable(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
 52    {
 53        SqlCommand cmd = new SqlCommand();
 54        SqlConnection conn = new SqlConnection(connectionString);
 55        SqlDataAdapter ad = new SqlDataAdapter(cmd);
 56        DataTable dt = new DataTable();
 57        try
 58        {
 59            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
 60            ad.Fill(dt);
 61            cmd.Parameters.Clear();
 62            return dt;
 63        }
 64        catch
 65        {
 66            throw;
 67        }
 68        finally
 69        {
 70            conn.Close();
 71        }
 72    }
 73    #endregion
 74    -执行增删改-#region -执行增删改-
 75    /**//// <summary>
 76    /// 执行增删改
 77    /// </summary>
 78    /// <param name="connectionString">连接字符串</param>
 79    /// <param name="cmdType">sql数据库执行的类型</param>
 80    /// <param name="cmdText">sql数据库执行的文本</param>
 81    /// <param name="commandParameters">参数列表</param>
 82    /// <returns>返回查询结果</returns>
 83    public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
 84    {
 85        SqlCommand cmd = new SqlCommand();
 86        using (SqlConnection conn = new SqlConnection(connectionString))
 87        {
 88            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
 89            int val = cmd.ExecuteNonQuery();
 90            cmd.Parameters.Clear();
 91            return val;
 92        }
 93    }
 94    /**//// <summary>
 95    /// 执行增删改
 96    /// </summary>
 97    /// <param name="connectionString">连接对象</param>
 98    /// <param name="cmdType">sql数据库执行的类型</param>
 99    /// <param name="cmdText">sql数据库执行的文本</param>
100    /// <param name="commandParameters">参数列表</param>
101    /// <returns>返回查询结果</returns>
102    public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
103    {
104        SqlCommand cmd = new SqlCommand();
105        PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
106        int val = cmd.ExecuteNonQuery();
107        cmd.Parameters.Clear();
108        return val;
109    }
110    #endregion
111    -数据库操作业务-#region -数据库操作业务-
112    /**//// <summary>
113    /// 数据库操作业务
114    /// </summary>
115    /// <param name="cmd">sql数据库执行对象</param>
116    /// <param name="conn">链接对象</param>
117    /// <param name="trans">sql数据库事务对象</param>
118    /// <param name="cmdType">sql数据库执行的类型</param>
119    /// <param name="cmdText">sql数据库执行的文本</param>
120    /// <param name="cmdParms">参数列表</param>
121    private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
122    {
123        if (conn.State != ConnectionState.Open)
124            conn.Open();
125        cmd.Connection = conn;
126        cmd.CommandText = cmdText;
127        if (trans != null)
128            cmd.Transaction = trans;
129        cmd.CommandType = cmdType;
130        if (cmdParms != null)
131        {
132            foreach (SqlParameter parm in cmdParms)
133                cmd.Parameters.Add(parm);
134        }
135    }
136    #endregion
137}
138