SQLHelper.cs
上传用户:tiancihang
上传日期:2014-03-12
资源大小:21387k
文件大小:13k
源码类别:

.net编程

开发平台:

C#

  1. using System;
  2. using System.Configuration;
  3. using System.Data;
  4. using System.Data.SqlClient;
  5. using System.Collections;
  6. namespace com.etong.DBUtility
  7. {
  8.     public abstract class SqlHelper
  9.     {
  10.         //Database connection strings
  11.         public static readonly string connectionString=ConfigurationManager.ConnectionStrings["connectionString"].ConnectionString;
  12.         //public static readonly string ConnectionStringInventoryDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString2"].ConnectionString;
  13.         //public static readonly string ConnectionStringOrderDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString3"].ConnectionString;
  14.         //public static readonly string ConnectionStringProfile = ConfigurationManager.ConnectionStrings["SQLProfileConnString"].ConnectionString;
  15.         // Hashtable to store cached parameters
  16.         private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
  17.         /// <summary>
  18.         /// Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
  19.         /// using the provided parameters.
  20.         /// </summary>
  21.         /// <remarks>
  22.         /// e.g.:  
  23.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  24.         /// </remarks>
  25.         /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  26.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  27.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  28.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  29.         /// <returns>an int representing the number of rows affected by the command</returns>
  30.         public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  31.         {
  32.             SqlCommand cmd = new SqlCommand();
  33.             using (SqlConnection conn = new SqlConnection(connectionString))
  34.             {
  35.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  36.                 int val = cmd.ExecuteNonQuery();
  37.                 cmd.Parameters.Clear();
  38.                 return val;
  39.             }
  40.         }
  41.         /// <summary>
  42.         /// Execute a SqlCommand (that returns no resultset) against an existing database connection 
  43.         /// using the provided parameters.
  44.         /// </summary>
  45.         /// <remarks>
  46.         /// e.g.:  
  47.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  48.         /// </remarks>
  49.         /// <param name="conn">an existing database connection</param>
  50.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  51.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  52.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  53.         /// <returns>an int representing the number of rows affected by the command</returns>
  54.         public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  55.         {
  56.             SqlCommand cmd = new SqlCommand();
  57.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  58.             int val = cmd.ExecuteNonQuery();
  59.             cmd.Parameters.Clear();
  60.             return val;
  61.         }
  62.         /// <summary>
  63.         /// Execute a SqlCommand (that returns no resultset) using an existing SQL Transaction 
  64.         /// using the provided parameters.
  65.         /// </summary>
  66.         /// <remarks>
  67.         /// e.g.:  
  68.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  69.         /// </remarks>
  70.         /// <param name="trans">an existing sql transaction</param>
  71.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  72.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  73.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  74.         /// <returns>an int representing the number of rows affected by the command</returns>
  75.         public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  76.         {
  77.             SqlCommand cmd = new SqlCommand();
  78.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
  79.             int val = cmd.ExecuteNonQuery();
  80.             cmd.Parameters.Clear();
  81.             return val;
  82.         }
  83.         /// <summary>
  84.         /// Execute a SqlCommand that returns a resultset against the database specified in the connection string 
  85.         /// using the provided parameters.
  86.         /// </summary>
  87.         /// <remarks>
  88.         /// e.g.:  
  89.         ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  90.         /// </remarks>
  91.         /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  92.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  93.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  94.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  95.         /// <returns>A SqlDataReader containing the results</returns>
  96.         public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  97.         {
  98.             SqlCommand cmd = new SqlCommand();
  99.             SqlConnection conn = new SqlConnection(connectionString);
  100.             // we use a try/catch here because if the method throws an exception we want to 
  101.             // close the connection throw code, because no datareader will exist, hence the 
  102.             // commandBehaviour.CloseConnection will not work
  103.             try
  104.             {
  105.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  106.                 SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
  107.                 cmd.Parameters.Clear();
  108.                 return rdr;
  109.             }
  110.             catch
  111.             {
  112.                 conn.Close();
  113.                 throw;
  114.             }
  115.         }
  116.         public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  117.         {
  118.             SqlCommand cmd = new SqlCommand();
  119.             using (SqlConnection conn = new SqlConnection(connectionString))
  120.             {
  121.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  122.                 cmd.Connection = conn;
  123.                 SqlDataAdapter da = new SqlDataAdapter(cmd);
  124.                 try
  125.                 {
  126.                     DataSet ds = new DataSet();
  127.                     da.Fill(ds);
  128.                     return ds;
  129.                 }
  130.                 catch
  131.                 {
  132.                     throw;
  133.                 }
  134.                 finally
  135.                 {
  136.                     cmd.Parameters.Clear();
  137.                 }
  138.             }
  139.         }
  140.         public static DataTable ExecuteDataTable(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  141.         {
  142.             DataSet ds = ExecuteDataSet(connectionString, cmdType, cmdText, commandParameters);
  143.             return (ds.Tables.Count > 0) ? ds.Tables[0] : null;
  144.         }
  145.         /// <summary>
  146.         /// Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string 
  147.         /// using the provided parameters.
  148.         /// </summary>
  149.         /// <remarks>
  150.         /// e.g.:  
  151.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  152.         /// </remarks>
  153.         /// <param name="connectionString">a valid connection string for a SqlConnection</param>
  154.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  155.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  156.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  157.         /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
  158.         public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  159.         {
  160.             SqlCommand cmd = new SqlCommand();
  161.             using (SqlConnection connection = new SqlConnection(connectionString))
  162.             {
  163.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  164.                 object val = cmd.ExecuteScalar();
  165.                 cmd.Parameters.Clear();
  166.                 return val;
  167.             }
  168.         }
  169.         /// <summary>
  170.         /// Execute a SqlCommand that returns the first column of the first record against an existing database connection 
  171.         /// using the provided parameters.
  172.         /// </summary>
  173.         /// <remarks>
  174.         /// e.g.:  
  175.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
  176.         /// </remarks>
  177.         /// <param name="conn">an existing database connection</param>
  178.         /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
  179.         /// <param name="commandText">the stored procedure name or T-SQL command</param>
  180.         /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
  181.         /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
  182.         public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
  183.         {
  184.             SqlCommand cmd = new SqlCommand();
  185.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  186.             object val = cmd.ExecuteScalar();
  187.             cmd.Parameters.Clear();
  188.             return val;
  189.         }
  190.         /// <summary>
  191.         /// add parameter array to the cache
  192.         /// </summary>
  193.         /// <param name="cacheKey">Key to the parameter cache</param>
  194.         /// <param name="cmdParms">an array of SqlParamters to be cached</param>
  195.         public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
  196.         {
  197.             parmCache[cacheKey] = commandParameters;
  198.         }
  199.         /// <summary>
  200.         /// Retrieve cached parameters
  201.         /// </summary>
  202.         /// <param name="cacheKey">key used to lookup parameters</param>
  203.         /// <returns>Cached SqlParamters array</returns>
  204.         public static SqlParameter[] GetCachedParameters(string cacheKey)
  205.         {
  206.             SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
  207.             if (cachedParms == null)
  208.                 return null;
  209.             SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
  210.             for (int i = 0, j = cachedParms.Length; i < j; i++)
  211.                 clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
  212.             return clonedParms;
  213.         }
  214.         /// <summary>
  215.         /// Prepare a command for execution
  216.         /// </summary>
  217.         /// <param name="cmd">SqlCommand object</param>
  218.         /// <param name="conn">SqlConnection object</param>
  219.         /// <param name="trans">SqlTransaction object</param>
  220.         /// <param name="cmdType">Cmd type e.g. stored procedure or text</param>
  221.         /// <param name="cmdText">Command text, e.g. Select * from Products</param>
  222.         /// <param name="cmdParms">SqlParameters to use in the command</param>
  223.         private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
  224.         {
  225.             if (conn.State != ConnectionState.Open)
  226.                 conn.Open();
  227.             cmd.Connection = conn;
  228.             cmd.CommandText = cmdText;
  229.             if (trans != null)
  230.                 cmd.Transaction = trans;
  231.             cmd.CommandType = cmdType;
  232.             if (cmdParms != null)
  233.             {
  234.                 foreach (SqlParameter parm in cmdParms)
  235.                     cmd.Parameters.Add(parm);
  236.             }
  237.         }
  238.     }
  239. }