zoukankan      html  css  js  c++  java
  • 公共的数据库访问访问类 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
  • 相关阅读:
    Qt串口的使用记录
    CImage灰度化
    (记录)MSYS2+MINGW32编译ffmpeg过程
    Blas 基本函数功能
    blas中dgemm_的用法
    选择、插入、冒泡排序
    简单的页面
    中国大学排名
    爬bing 主页
    读书报告
  • 原文地址:https://www.cnblogs.com/wanzhongjun/p/6783487.html
Copyright © 2011-2022 走看看