SqlHelper.cs
上传用户:xiecaij
上传日期:2015-02-08
资源大小:2016k
文件大小:15k
源码类别:

百货/超市行业

开发平台:

ASP/ASPX

  1. //===============================================================================
  2. // This file is based on the Microsoft Data Access Application Block for .NET
  3. // For more information please go to 
  4. // http://msdn.microsoft.com/library/en-us/dnbda/html/daab-rm.asp
  5. //===============================================================================
  6. using System;
  7. using System.Configuration;
  8. using System.Data;
  9. using System.Data.SqlClient;
  10. using System.Collections;
  11. namespace eshop.DAL 
  12. {
  13. /// <summary>
  14. /// The SqlHelper class is intended to encapsulate high performance, 
  15. /// scalable best practices for common uses of SqlClient.
  16. /// </summary>
  17. public abstract class SQLHelper 
  18. {
  19. //Database connection strings
  20. public static readonly string CONN_STRING = ConfigurationSettings.AppSettings["ConnectionString"];
  21. // Hashtable to store cached parameters
  22. private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
  23. /// <summary>
  24. /// Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
  25. /// using the provided parameters.
  26. /// </summary>
  27. /// <remarks>
  28. /// e.g.:  
  29. ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  30. /// </remarks>
  31. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  32. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  33. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  34. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  35. /// <returns>an int representing the number of rows affected by the command</returns>
  36. public static int ExecuteNonQuery(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  37. {
  38. SqlCommand cmd = new SqlCommand();
  39. using (SqlConnection conn = new SqlConnection(connString)) 
  40. {
  41. PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
  42. int val = cmd.ExecuteNonQuery();
  43. //清除cmd的参数
  44. cmd.Parameters.Clear();
  45. return val;
  46. }
  47. }
  48. /// <summary>
  49. /// Execute a SqlCommand (that returns no resultset) against an existing database connection 
  50. /// using the provided parameters.
  51. /// </summary>
  52. /// <remarks>
  53. /// e.g.:  
  54. ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  55. /// </remarks>
  56. /// <param name="conn">an existing database connection</param>
  57. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  58. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  59. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  60. /// <returns>an int representing the number of rows affected by the command</returns>
  61. public static int ExecuteNonQuery(SqlConnection conn, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  62. {
  63. SqlCommand cmd = new SqlCommand();
  64. PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
  65. int val = cmd.ExecuteNonQuery();
  66. cmd.Parameters.Clear();
  67. return val;
  68. }
  69. /// <summary>
  70. /// Execute a SqlCommand (that returns no resultset) using an existing SQL Transaction 
  71. /// using the provided parameters.
  72. /// </summary>
  73. /// <remarks>
  74. /// e.g.:  
  75. ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  76. /// </remarks>
  77. /// <param name="trans">an existing sql transaction</param>
  78. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  79. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  80. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  81. /// <returns>an int representing the number of rows affected by the command</returns>
  82. public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  83. {
  84. SqlCommand cmd = new SqlCommand();
  85. PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);
  86. int val = cmd.ExecuteNonQuery();
  87. cmd.Parameters.Clear();
  88. return val;
  89. }
  90. /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
  91. /// the connection string. 
  92. /// </summary>
  93. /// <remarks>
  94. /// e.g.:  
  95. ///  SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
  96. /// </remarks>
  97. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  98. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  99. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  100. /// <returns>a SqlDataReader containing the resultset generated by the command</returns>
  101. public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
  102. {
  103. //pass through the call providing null for the set of SqlParameters
  104. return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
  105. }
  106. /// <summary>
  107. /// Execute a SqlCommand that returns a resultset against the database specified in the connection string 
  108. /// using the provided parameters.
  109. /// </summary>
  110. /// <remarks>
  111. /// e.g.:  
  112. ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  113. /// </remarks>
  114. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  115. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  116. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  117. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  118. /// <returns>A SqlDataReader containing the results</returns>
  119. public static SqlDataReader ExecuteReader(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  120. {
  121. SqlCommand cmd = new SqlCommand();
  122. SqlConnection conn = new SqlConnection(connString);
  123. try 
  124. {
  125. PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
  126. SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
  127. cmd.Parameters.Clear();
  128. return rdr;
  129. }
  130. catch 
  131. {
  132. conn.Close();
  133. throw;
  134. }
  135. }
  136. /// <summary>
  137. /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
  138. /// the connection string. 
  139. /// </summary>
  140. /// <remarks>
  141. /// e.g.:  
  142. ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
  143. /// </remarks>
  144. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  145. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  146. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  147. /// <returns>a dataset containing the resultset generated by the command</returns>
  148. public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
  149. {
  150. return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
  151. }
  152. /// <summary>
  153. /// Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
  154. /// using the provided parameters.
  155. /// </summary>
  156. /// <remarks>
  157. /// e.g.:  
  158. ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
  159. /// </remarks>
  160. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  161. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  162. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  163. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  164. /// <returns>a dataset containing the resultset generated by the command</returns>
  165. public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
  166. {
  167. using (SqlConnection cn = new SqlConnection(connectionString))
  168. {
  169. cn.Open();
  170. //调用重载方法
  171. return ExecuteDataset(cn, commandType, commandText, commandParameters);
  172. }
  173. }
  174. /// <summary>
  175. /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
  176. /// </summary>
  177. /// <remarks>
  178. /// e.g.:  
  179. ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
  180. /// </remarks>
  181. /// <param name="connection">a valid SqlConnection</param>
  182. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  183. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  184. /// <returns>a dataset containing the resultset generated by the command</returns>
  185. public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
  186. {
  187. return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
  188. }
  189. /// <summary>
  190. /// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
  191. /// using the provided parameters.
  192. /// </summary>
  193. /// <remarks>
  194. /// e.g.:  
  195. ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
  196. /// </remarks>
  197. /// <param name="connection">a valid SqlConnection</param>
  198. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  199. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  200. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  201. /// <returns>a dataset containing the resultset generated by the command</returns>
  202. public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
  203. {
  204. //创建一个SqlCommand对象,并对其进行初始化
  205. SqlCommand cmd = new SqlCommand();
  206. PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);
  207. //创建SqlDataAdapter对象以及DataSet
  208. SqlDataAdapter da = new SqlDataAdapter(cmd);
  209. DataSet ds = new DataSet();
  210. //填充ds
  211. da.Fill(ds);
  212. // 清除cmd的参数集合
  213. cmd.Parameters.Clear();
  214. //返回ds
  215. return ds;
  216. }
  217. /// <summary>
  218. /// Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string 
  219. /// using the provided parameters.
  220. /// </summary>
  221. /// <remarks>
  222. /// e.g.:  
  223. ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  224. /// </remarks>
  225. /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  226. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  227. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  228. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  229. /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
  230. public static object ExecuteScalar(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  231. {
  232. SqlCommand cmd = new SqlCommand();
  233. using (SqlConnection conn = new SqlConnection(connString)) 
  234. {
  235. PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
  236. object val = cmd.ExecuteScalar();
  237. cmd.Parameters.Clear();
  238. return val;
  239. }
  240. }
  241. /// <summary>
  242. /// Execute a SqlCommand that returns the first column of the first record against an existing database connection 
  243. /// using the provided parameters.
  244. /// </summary>
  245. /// <remarks>
  246. /// e.g.:  
  247. ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  248. /// </remarks>
  249. /// <param name="conn">an existing database connection</param>
  250. /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  251. /// <param name="commandText">the stored procedure name or T-SQL command</param>
  252. /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  253. /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
  254. public static object ExecuteScalar(SqlConnection conn, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms) 
  255. {
  256. SqlCommand cmd = new SqlCommand();
  257. PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
  258. object val = cmd.ExecuteScalar();
  259. cmd.Parameters.Clear();
  260. return val;
  261. }
  262. /// <summary>
  263. /// add parameter array to the cache
  264. /// </summary>
  265. /// <param name="cacheKey">Key to the parameter cache</param>
  266. /// <param name="cmdParms">an array of SqlParamters to be cached</param>
  267. public static void CacheParameters(string cacheKey, params SqlParameter[] cmdParms) 
  268. {
  269. parmCache[cacheKey] = cmdParms;
  270. }
  271. /// <summary>
  272. /// Retrieve cached parameters
  273. /// </summary>
  274. /// <param name="cacheKey">key used to lookup parameters</param>
  275. /// <returns>Cached SqlParamters array</returns>
  276. public static SqlParameter[] GetCachedParameters(string cacheKey) 
  277. {
  278. SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
  279. if (cachedParms == null)
  280. return null;
  281. SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
  282. for (int i = 0, j = cachedParms.Length; i < j; i++)
  283. clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
  284. return clonedParms;
  285. }
  286. /// <summary>
  287. /// Prepare a command for execution
  288. /// </summary>
  289. /// <param name="cmd">SqlCommand object</param>
  290. /// <param name="conn">SqlConnection object</param>
  291. /// <param name="trans">SqlTransaction object</param>
  292. /// <param name="cmdType">Cmd type e.g. stored procedure or text</param>
  293. /// <param name="cmdText">Command text, e.g. Select * from Products</param>
  294. /// <param name="cmdParms">SqlParameters to use in the command</param>
  295. private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms) 
  296. {
  297. //判断连接的状态。如果是关闭状态,则打开
  298. if (conn.State != ConnectionState.Open)
  299. conn.Open();
  300. //cmd属性赋值
  301. cmd.Connection = conn;
  302. cmd.CommandText = cmdText;
  303. //是否需要用到事务处理
  304. if (trans != null)
  305. cmd.Transaction = trans;
  306. cmd.CommandType = cmdType;
  307. //添加cmd需要的存储过程参数
  308. if (cmdParms != null) 
  309. {
  310. foreach (SqlParameter parm in cmdParms)
  311. cmd.Parameters.Add(parm);
  312. }
  313. }
  314. }
  315. }