首页 > 代码库 > 公共的数据库访问访问类 SqlHelper.cs

公共的数据库访问访问类 SqlHelper.cs

  1. /// <summary>  
  2. /// 类说明:公共的数据库访问访问类
  3. /// </summary>  
  4. using System;  
  5. using System.Collections.Generic;  
  6. using System.Text;  
  7. using System.Data;  
  8. using System.Data.SqlClient;  
  9. using System.Collections;  
  10. namespace DotNet.Utilities  
  11. {  
  12.     /// <summary>  
  13.     /// 数据库的通用访问代码  
  14.     /// 此类为抽象类,  
  15.     /// 不允许实例化,在应用时直接调用即可  
  16.     /// </summary>  
  17.     public abstract class SqlHelper  
  18.     {  
  19.         /// <summary>  
  20.         /// 数据库连接字符串  
  21.         /// </summary>  
  22.         public static readonly string connectionString = System.Configuration.ConfigurationSettings.AppSettings["con"].ToString().Trim();  
  23.   
  24.         // Hashtable to store cached parameters  
  25.         private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());  
  26.  
  27.         #region //ExecteNonQuery方法  
  28.         /// <summary>  
  29.         ///执行一个不需要返回值的SqlCommand命令,通过指定专用的连接字符串。  
  30.         /// 使用参数数组形式提供参数列表   
  31.         /// </summary>  
  32.         /// <param name="connectionString">一个有效的数据库连接字符串</param>  
  33.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  34.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  35.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  36.         /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>  
  37.         public static int ExecteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  38.         {  
  39.             SqlCommand cmd = new SqlCommand();  
  40.             using (SqlConnection conn = new SqlConnection(connectionString))  
  41.             {  
  42.                 //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中  
  43.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  44.                 int val = cmd.ExecuteNonQuery();  
  45.                 //清空SqlCommand中的参数列表  
  46.                 cmd.Parameters.Clear();  
  47.                 return val;  
  48.             }  
  49.         }  
  50.   
  51.         /// <summary>  
  52.         ///执行一个不需要返回值的SqlCommand命令,通过指定专用的连接字符串。  
  53.         /// 使用参数数组形式提供参数列表   
  54.         /// </summary>  
  55.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  56.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  57.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  58.         /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>  
  59.         public static int ExecteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  60.         {  
  61.             return ExecteNonQuery(connectionString, cmdType, cmdText, commandParameters);  
  62.         }  
  63.   
  64.         /// <summary>  
  65.         ///存储过程专用  
  66.         /// </summary>  
  67.         /// <param name="cmdText">存储过程的名字</param>  
  68.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  69.         /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>  
  70.         public static int ExecteNonQueryProducts(string cmdText, params SqlParameter[] commandParameters)  
  71.         {  
  72.             return ExecteNonQuery(CommandType.StoredProcedure, cmdText, commandParameters);  
  73.         }  
  74.   
  75.         /// <summary>  
  76.         ///Sql语句专用  
  77.         /// </summary>  
  78.         /// <param name="cmdText">T_Sql语句</param>  
  79.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  80.         /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>  
  81.         public static int ExecteNonQueryText(string cmdText, params SqlParameter[] commandParameters)  
  82.         {  
  83.             return ExecteNonQuery(CommandType.Text, cmdText, commandParameters);  
  84.         }  
  85.  
  86.         #endregion  
  87.  
  88.         #region//GetTable方法  
  89.   
  90.         /// <summary>  
  91.         /// 执行一条返回结果集的SqlCommand,通过一个已经存在的数据库连接  
  92.         /// 使用参数数组提供参数  
  93.         /// </summary>  
  94.         /// <param name="connecttionString">一个现有的数据库连接</param>  
  95.         /// <param name="cmdTye">SqlCommand命令类型</param>  
  96.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  97.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  98.         /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>  
  99.         public static DataTableCollection GetTable(string connecttionString, CommandType cmdTye, string cmdText, SqlParameter[] commandParameters)  
  100.         {  
  101.             SqlCommand cmd = new SqlCommand();  
  102.             DataSet ds = new DataSet();  
  103.             using (SqlConnection conn = new SqlConnection(connecttionString))  
  104.             {  
  105.                 PrepareCommand(cmd, conn, null, cmdTye, cmdText, commandParameters);  
  106.                 SqlDataAdapter adapter = new SqlDataAdapter();  
  107.                 adapter.SelectCommand = cmd;  
  108.                 adapter.Fill(ds);  
  109.             }  
  110.             DataTableCollection table = ds.Tables;  
  111.             return table;  
  112.         }  
  113.   
  114.         /// <summary>  
  115.         /// 执行一条返回结果集的SqlCommand,通过一个已经存在的数据库连接  
  116.         /// 使用参数数组提供参数  
  117.         /// </summary>  
  118.         /// <param name="cmdTye">SqlCommand命令类型</param>  
  119.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  120.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  121.         /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>  
  122.         public static DataTableCollection GetTable(CommandType cmdTye, string cmdText, SqlParameter[] commandParameters)  
  123.         {  
  124.             return GetTable(SqlHelper.connectionString, cmdTye, cmdText, commandParameters);  
  125.         }  
  126.   
  127.         /// <summary>  
  128.         /// 存储过程专用  
  129.         /// </summary>  
  130.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  131.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  132.         /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>  
  133.         public static DataTableCollection GetTableProducts(string cmdText, SqlParameter[] commandParameters)  
  134.         {  
  135.             return GetTable(CommandType.StoredProcedure, cmdText, commandParameters);  
  136.         }  
  137.   
  138.         /// <summary>  
  139.         /// Sql语句专用  
  140.         /// </summary>  
  141.         /// <param name="cmdText"> T-SQL 语句</param>  
  142.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  143.         /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>  
  144.         public static DataTableCollection GetTableText(string cmdText, SqlParameter[] commandParameters)  
  145.         {  
  146.             return GetTable(CommandType.Text, cmdText, commandParameters);  
  147.         }  
  148.  
  149.         #endregion  
  150.   
  151.         /// <summary>  
  152.         /// 为执行命令准备参数  
  153.         /// </summary>  
  154.         /// <param name="cmd">SqlCommand 命令</param>  
  155.         /// <param name="conn">已经存在的数据库连接</param>  
  156.         /// <param name="trans">数据库事物处理</param>  
  157.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  158.         /// <param name="cmdText">Command text,T-SQL语句 例如 Select * from Products</param>  
  159.         /// <param name="cmdParms">返回带参数的命令</param>  
  160.         private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)  
  161.         {  
  162.             //判断数据库连接状态  
  163.             if (conn.State != ConnectionState.Open)  
  164.                 conn.Open();  
  165.             cmd.Connection = conn;  
  166.             cmd.CommandText = cmdText;  
  167.             //判断是否需要事物处理  
  168.             if (trans != null)  
  169.                 cmd.Transaction = trans;  
  170.             cmd.CommandType = cmdType;  
  171.             if (cmdParms != null)  
  172.             {  
  173.                 foreach (SqlParameter parm in cmdParms)  
  174.                     cmd.Parameters.Add(parm);  
  175.             }  
  176.         }  
  177.   
  178.         /// <summary>  
  179.         /// Execute a SqlCommand that returns a resultset against the database specified in the connection string   
  180.         /// using the provided parameters.  
  181.         /// </summary>  
  182.         /// <param name="connectionString">一个有效的数据库连接字符串</param>  
  183.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  184.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  185.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  186.         /// <returns>A SqlDataReader containing the results</returns>  
  187.         public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  188.         {  
  189.             SqlCommand cmd = new SqlCommand();  
  190.             SqlConnection conn = new SqlConnection(connectionString);  
  191.             // we use a try/catch here because if the method throws an exception we want to   
  192.             // close the connection throw code, because no datareader will exist, hence the   
  193.             // commandBehaviour.CloseConnection will not work  
  194.             try  
  195.             {  
  196.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  197.                 SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  198.                 cmd.Parameters.Clear();  
  199.                 return rdr;  
  200.             }  
  201.             catch  
  202.             {  
  203.                 conn.Close();  
  204.                 throw;  
  205.             }  
  206.         }  
  207.  
  208.         #region//ExecuteDataSet方法  
  209.   
  210.         /// <summary>  
  211.         /// return a dataset  
  212.         /// </summary>  
  213.         /// <param name="connectionString">一个有效的数据库连接字符串</param>  
  214.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  215.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  216.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  217.         /// <returns>return a dataset</returns>  
  218.         public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  219.         {  
  220.             SqlCommand cmd = new SqlCommand();  
  221.             try  
  222.             {  
  223.                 using (SqlConnection conn = new SqlConnection(connectionString))  
  224.                 {  
  225.                     PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  226.                     SqlDataAdapter da = new SqlDataAdapter();  
  227.                     DataSet ds = new DataSet();  
  228.                     da.SelectCommand = cmd;  
  229.                     da.Fill(ds);  
  230.                     return ds;  
  231.                 }  
  232.             }  
  233.             catch  
  234.             {  
  235.                 throw;  
  236.             }  
  237.         }  
  238.   
  239.         /// <summary>  
  240.         /// 返回一个DataSet  
  241.         /// </summary>  
  242.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  243.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  244.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  245.         /// <returns>return a dataset</returns>  
  246.         public static DataSet ExecuteDataSet(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  247.         {  
  248.             return ExecuteDataSet(connectionString, cmdType, cmdText, commandParameters);  
  249.         }  
  250.   
  251.         /// <summary>  
  252.         /// 返回一个DataSet  
  253.         /// </summary>  
  254.         /// <param name="cmdText">存储过程的名字</param>  
  255.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  256.         /// <returns>return a dataset</returns>  
  257.         public static DataSet ExecuteDataSetProducts(string cmdText, params SqlParameter[] commandParameters)  
  258.         {  
  259.             return ExecuteDataSet(connectionString, CommandType.StoredProcedure, cmdText, commandParameters);  
  260.         }  
  261.   
  262.         /// <summary>  
  263.         /// 返回一个DataSet  
  264.         /// </summary>  
  265.         /// <param name="cmdText">T-SQL 语句</param>  
  266.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  267.         /// <returns>return a dataset</returns>  
  268.         public static DataSet ExecuteDataSetText(string cmdText, params SqlParameter[] commandParameters)  
  269.         {  
  270.             return ExecuteDataSet(connectionString, CommandType.Text, cmdText, commandParameters);  
  271.         }  
  272.   
  273.         public static DataView ExecuteDataSet(string connectionString, string sortExpression, string direction, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  274.         {  
  275.             SqlCommand cmd = new SqlCommand();  
  276.             try  
  277.             {  
  278.                 using (SqlConnection conn = new SqlConnection(connectionString))  
  279.                 {  
  280.                     PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  281.                     SqlDataAdapter da = new SqlDataAdapter();  
  282.                     DataSet ds = new DataSet();  
  283.                     da.SelectCommand = cmd;  
  284.                     da.Fill(ds);  
  285.                     DataView dv = ds.Tables[0].DefaultView;  
  286.                     dv.Sort = sortExpression + " " + direction;  
  287.                     return dv;  
  288.                 }  
  289.             }  
  290.             catch  
  291.             {  
  292.   
  293.                 throw;  
  294.             }  
  295.         }  
  296.         #endregion  
  297.  
  298.         #region // ExecuteScalar方法  
  299.   
  300.         /// <summary>  
  301.         /// 返回第一行的第一列  
  302.         /// </summary>  
  303.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  304.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  305.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  306.         /// <returns>返回一个对象</returns>  
  307.         public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  308.         {  
  309.             return ExecuteScalar(SqlHelper.connectionString, cmdType, cmdText, commandParameters);  
  310.         }  
  311.   
  312.         /// <summary>  
  313.         /// 返回第一行的第一列存储过程专用  
  314.         /// </summary>  
  315.         /// <param name="cmdText">存储过程的名字</param>  
  316.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  317.         /// <returns>返回一个对象</returns>  
  318.         public static object ExecuteScalarProducts(string cmdText, params SqlParameter[] commandParameters)  
  319.         {  
  320.             return ExecuteScalar(SqlHelper.connectionString, CommandType.StoredProcedure, cmdText, commandParameters);  
  321.         }  
  322.   
  323.         /// <summary>  
  324.         /// 返回第一行的第一列Sql语句专用  
  325.         /// </summary>  
  326.         /// <param name="cmdText">者 T-SQL 语句</param>  
  327.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  328.         /// <returns>返回一个对象</returns>  
  329.         public static object ExecuteScalarText(string cmdText, params SqlParameter[] commandParameters)  
  330.         {  
  331.             return ExecuteScalar(SqlHelper.connectionString, CommandType.Text, cmdText, commandParameters);  
  332.         }  
  333.   
  334.         /// <summary>  
  335.         /// Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string   
  336.         /// using the provided parameters.  
  337.         /// </summary>  
  338.         /// <remarks>  
  339.         /// e.g.:    
  340.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  341.         /// </remarks>  
  342.         /// <param name="connectionString">一个有效的数据库连接字符串</param>  
  343.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  344.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  345.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  346.         /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>  
  347.         public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  348.         {  
  349.             SqlCommand cmd = new SqlCommand();  
  350.   
  351.             using (SqlConnection connection = new SqlConnection(connectionString))  
  352.             {  
  353.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
  354.                 object val = cmd.ExecuteScalar();  
  355.                 cmd.Parameters.Clear();  
  356.                 return val;  
  357.             }  
  358.         }  
  359.   
  360.         /// <summary>  
  361.         /// Execute a SqlCommand that returns the first column of the first record against an existing database connection   
  362.         /// using the provided parameters.  
  363.         /// </summary>  
  364.         /// <remarks>  
  365.         /// e.g.:    
  366.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  367.         /// </remarks>  
  368.         /// <param name="connectionString">一个有效的数据库连接字符串</param>  
  369.         /// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>  
  370.         /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>  
  371.         /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  372.         /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>  
  373.         public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)  
  374.         {  
  375.             SqlCommand cmd = new SqlCommand();  
  376.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
  377.             object val = cmd.ExecuteScalar();  
  378.             cmd.Parameters.Clear();  
  379.             return val;  
  380.         }  
  381.  
  382.         #endregion  
  383.   
  384.         /// <summary>  
  385.         /// add parameter array to the cache  
  386.         /// </summary>  
  387.         /// <param name="cacheKey">Key to the parameter cache</param>  
  388.         /// <param name="cmdParms">an array of SqlParamters to be cached</param>  
  389.         public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)  
  390.         {  
  391.             parmCache[cacheKey] = commandParameters;  
  392.         }  
  393.   
  394.         /// <summary>  
  395.         /// Retrieve cached parameters  
  396.         /// </summary>  
  397.         /// <param name="cacheKey">key used to lookup parameters</param>  
  398.         /// <returns>Cached SqlParamters array</returns>  
  399.         public static SqlParameter[] GetCachedParameters(string cacheKey)  
  400.         {  
  401.             SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];  
  402.             if (cachedParms == null)  
  403.                 return null;  
  404.             SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];  
  405.             for (int i = 0, j = cachedParms.Length; i < j; i++)  
  406.                 clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();  
  407.             return clonedParms;  
  408.         }  
  409.   
  410.         /// <summary>  
  411.         /// 检查是否存在  
  412.         /// </summary>  
  413.         /// <param name="strSql">Sql语句</param>  
  414.         /// <param name="cmdParms">参数</param>  
  415.         /// <returns>bool结果</returns>  
  416.         public static bool Exists(string strSql, params SqlParameter[] cmdParms)  
  417.         {  
  418.             int cmdresult = Convert.ToInt32(ExecuteScalar(connectionString, CommandType.Text, strSql, cmdParms));  
  419.             if (cmdresult == 0)  
  420.             {  
  421.                 return false;  
  422.             }  
  423.             else  
  424.             {  
  425.                 return true;  
  426.             }  
  427.         }  
  428.     }  
  429. }
  430. //更多基类库请访问:
  431. //http://tool.sufeinet.com/CodePreview/CodeView.aspx

公共的数据库访问访问类 SqlHelper.cs