DBHelper

using System;

using System.Collections;

using System.Collections.Specialized;
0006 using System.Data;
0007 using System.Data.SqlClient;
0008 using System.Configuration;
0009 using System.Data.Common;
0010 using System.Collections.Generic;
0011 namespace Legalsoft.Wizard.DBUtility
0012 {
0013  public enum EffentNextType
0014  {
0015  /// <summary>
0016  /// 对其他语句无任何影响
0017  /// </summary>
0018  None,
0019  /// <summary>
0020  /// 当前语句必须为"SELECT COUNT(1) FROM .."格式,如果存在则继续执行,不存在回滚事务
0021  /// </summary>
0022  WhenHaveContine,
0023  /// <summary>
0024  /// 当前语句必须为"SELECT COUNT(1) FROM .."格式,如果不存在则继续执行,存在回滚事务
0025  /// </summary>
0026  WhenNoHaveContine,
0027  /// <summary>
0028  /// 当前语句影响到的行数必须大于0,否则回滚事务
0029  /// </summary>
0030  ExcuteEffectRows,
0031  /// <summary>
0032  /// 引发事件-当前语句必须为"SELECT COUNT(1) FROM .."格式,如果不存在则继续执行,存在回滚事务
0033  /// </summary>
0034  SolicitationEvent
0035  }
0036  public class CommandInfo
0037  {
0038  public object ShareObject = null;
0039  public object OriginalData = null;
0040  event EventHandler _solicitationEvent;
0041  public event EventHandler SolicitationEvent
0042  {
0043  add
0044  {
0045  _solicitationEvent += value;
0046  }
0047  remove
0048  {
0049  _solicitationEvent -= value;
0050  }
0051  }
0052  public void OnSolicitationEvent()
0053  {
0054  if (_solicitationEvent != null)
0055  {
0056  _solicitationEvent(this,new EventArgs());
0057  }
0058  }
0059  public string CommandText;
0060  public System.Data.Common.DbParameter[] Parameters;
0061  public EffentNextType EffentNextType = EffentNextType.None;
0062  public CommandInfo()
0063  {
0064  }
0065  public CommandInfo(string sqlText, SqlParameter[] para)
0066  {
0067  this.CommandText = sqlText;
0068  this.Parameters = para;
0069  }
0070  public CommandInfo(string sqlText, SqlParameter[] para, EffentNextType type)
0071  {
0072  this.CommandText = sqlText;
0073  this.Parameters = para;
0074  this.EffentNextType = type;
0075  }
0076  }
0077  /// <summary>
0078  /// 数据访问抽象基础类
0079  /// </summary>
0080  public abstract class SQLHelper
0081  {
0082  //数据库连接字符串(web.config来配置),可以动态更改connectionString支持多数据库.
0083  public static string connectionString = "";
0084  public SQLHelper()
0085  {
0086  connectionString = @"DATA SOURCE=(local);UID=sa;PWD=111111;DATABASE=LegalSoft";
0087  }
0088  #region 公用方法
0089  /// <summary>
0090  /// 读取指定图片的二进制信息
0091  /// </summary>
0092  /// <param name="id"></param>
0093  /// <returns></returns>
0094  public object LoadImage(int id)
0095  {
0096  SqlConnection myConnection = new SqlConnection(connectionString);
0097  SqlCommand myCommand = new SqlCommand("SELECT [bImage] FROM [tblCAIPIAO_NEWS_IMG] WHERE <a href="mailto:id=@id" target="_blank">id=@id</a>", myConnection);
0098  myCommand.CommandType = CommandType.Text;
0099  myCommand.Parameters.Add(new SqlParameter("@id", id));
0100  myConnection.Open();
0101  object result = myCommand.ExecuteScalar();
0102  try
0103  {
0104  return new System.IO.MemoryStream((byte[])result);
0105  }
0106  catch (ArgumentNullException e)
0107  {
0108  return null;
0109  }
0110  finally
0111  {
0112  myConnection.Close();
0113  }
0114  }
0115  /// <summary>
0116  /// 判断是否存在某表的某个字段
0117  /// </summary>
0118  /// <param name="tableName">表名称</param>
0119  /// <param name="columnName">列名称</param>
0120  /// <returns>是否存在</returns>
0121  public static bool ColumnExists(string tableName, string columnName)
0122  {
0123  string sql = "select count(1) from syscolumns where [id]=object_id("" + tableName + "") and [name]="" + columnName + """;
0124  object res = GetSingle(sql);
0125  if (res == null)
0126  {
0127  return false;
0128  }
0129  return Convert.ToInt32(res) > 0;
0130  }
0131  public static int GetMaxID(string FieldName, string TableName)
0132  {
0133  string strsql = "select max(" + FieldName + ")+1 from " + TableName;
0134  object obj = SQLHelper.GetSingle(strsql);
0135  if (obj == null)
0136  {
0137  return 1;
0138  }
0139  else
0140  {
0141  return int.Parse(obj.ToString());
0142  }
0143  }
0144  public static bool Exists(string strSql)
0145  {
0146  object obj = SQLHelper.GetSingle(strSql);
0147  int cmdresult;
0148  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0149  {
0150  cmdresult = 0;
0151  }
0152  else
0153  {
0154  cmdresult = int.Parse(obj.ToString());
0155  }
0156  if (cmdresult == 0)
0157  {
0158  return false;
0159  }
0160  else
0161  {
0162  return true;
0163  }
0164  }
0165  /// <summary>
0166  /// 表是否存在
0167  /// </summary>
0168  /// <param name="TableName"></param>
0169  /// <returns></returns>
0170  public static bool TabExists(string TableName)
0171  {
0172  string strsql = "select count(*) from sysobjects where id = object_id(N"[" + TableName + "]") and OBJECTPROPERTY(id, N"IsUserTable") = 1";
0173  //string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N"[dbo].[" + TableName + "]") AND type in (N"U")";
0174  object obj = SQLHelper.GetSingle(strsql);
0175  int cmdresult;
0176  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0177  {
0178  cmdresult = 0;
0179  }
0180  else
0181  {
0182  cmdresult = int.Parse(obj.ToString());
0183  }
0184  if (cmdresult == 0)
0185  {
0186  return false;
0187  }
0188  else
0189  {
0190  return true;
0191  }
0192  }
0193  public static bool Exists(string strSql, params SqlParameter[] cmdParms)
0194  {
0195  object obj = SQLHelper.GetSingle(strSql, cmdParms);
0196  int cmdresult;
0197  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0198  {
0199  cmdresult = 0;
0200  }
0201  else
0202  {
0203  cmdresult = int.Parse(obj.ToString());
0204  }
0205  if (cmdresult == 0)
0206  {
0207  return false;
0208  }
0209  else
0210  {
0211  return true;
0212  }
0213  }
0214  #endregion
0215  #region 执行简单SQL语句
0216  /// <summary>
0217  /// 执行SQL语句,返回影响的记录数
0218  /// </summary>
0219  /// <param name="SQLString">SQL语句</param>
0220  /// <returns>影响的记录数</returns>
0221  public static int ExecuteSql(string SQLString)
0222  {
0223  using (SqlConnection connection = new SqlConnection(connectionString))
0224  {
0225  using (SqlCommand cmd = new SqlCommand(SQLString, connection))
0226  {
0227  try
0228  {
0229  connection.Open();
0230  int rows = cmd.ExecuteNonQuery();
0231  return rows;
0232  }
0233  catch (System.Data.SqlClient.SqlException e)
0234  {
0235  connection.Close();
0236  throw e;
0237  }
0238  }
0239  }
0240  }
0241  public static int ExecuteSqlByTime(string SQLString, int Times)
0242  {
0243  using (SqlConnection connection = new SqlConnection(connectionString))
0244  {
0245  using (SqlCommand cmd = new SqlCommand(SQLString, connection))
0246  {
0247  try
0248  {
0249  connection.Open();
0250  cmd.CommandTimeout = Times;
0251  int rows = cmd.ExecuteNonQuery();
0252  return rows;
0253  }
0254  catch (System.Data.SqlClient.SqlException e)
0255  {
0256  connection.Close();
0257  throw e;
0258  }
0259  }
0260  }
0261  }
0262  /// <summary>
0263  /// 执行Sql和Oracle滴混合事务
0264  /// </summary>
0265  /// <param name="list">SQL命令行列表</param>
0266  /// <param name="oracleCmdSqlList">Oracle命令行列表</param>
0267  /// <returns>执行结果 0-由于SQL造成事务失败 -1 由于Oracle造成事务失败 1-整体事务执行成功</returns>
0268  public static int ExecuteSqlTran(List<CommandInfo> list, List<CommandInfo> oracleCmdSqlList)
0269  {
0270  using (SqlConnection conn = new SqlConnection(connectionString))
0271  {
0272  conn.Open();
0273  SqlCommand cmd = new SqlCommand();
0274  cmd.Connection = conn;
0275  SqlTransaction tx = conn.BeginTransaction();
0276  cmd.Transaction = tx;
0277  try
0278  {
0279  foreach (CommandInfo myDE in list)
0280  {
0281  string cmdText = myDE.CommandText;
0282  SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
0283  PrepareCommand(cmd, conn, tx, cmdText, cmdParms);
0284  if (myDE.EffentNextType == EffentNextType.SolicitationEvent)
0285  {
0286  if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
0287  {
0288  tx.Rollback();
0289  throw new Exception("违背要求" + myDE.CommandText + "必须符合select count(..的格式");
0290  //return 0;
0291  }
0292  object obj = cmd.ExecuteScalar();
0293  bool isHave = false;
0294  if (obj == null && obj == DBNull.Value)
0295  {
0296  isHave = false;
0297  }
0298  isHave = Convert.ToInt32(obj) > 0;
0299  if (isHave)
0300  {
0301  //引发事件
0302  myDE.OnSolicitationEvent();
0303  }
0304  }
0305  if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
0306  {
0307  if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
0308  {
0309  tx.Rollback();
0310  throw new Exception("SQL:违背要求" + myDE.CommandText + "必须符合select count(..的格式");
0311  //return 0;
0312  }
0313  object obj = cmd.ExecuteScalar();
0314  bool isHave = false;
0315  if (obj == null && obj == DBNull.Value)
0316  {
0317  isHave = false;
0318  }
0319  isHave = Convert.ToInt32(obj) > 0;
0320  if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
0321  {
0322  tx.Rollback();
0323  throw new Exception("SQL:违背要求" + myDE.CommandText + "返回值必须大于0");
0324  //return 0;
0325  }
0326  if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
0327  {
0328  tx.Rollback();
0329  throw new Exception("SQL:违背要求" + myDE.CommandText + "返回值必须等于0");
0330  //return 0;
0331  }
0332  continue;
0333  }
0334  int val = cmd.ExecuteNonQuery();
0335  if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
0336  {
0337  tx.Rollback();
0338  throw new Exception("SQL:违背要求" + myDE.CommandText + "必须有影响行");
0339  //return 0;
0340  }
0341  cmd.Parameters.Clear();
0342  }
0343  //string oraConnectionString = PubConstant.GetConnectionString("ConnectionStringPPC");
0344  //bool res = OracleHelper.ExecuteSqlTran(oraConnectionString, oracleCmdSqlList);
0345  //if (!res)
0346  //{
0347  // tx.Rollback();
0348  // throw new Exception("Oracle执行失败");
0349  // return -1;
0350  //}
0351  tx.Commit();
0352  return 1;
0353  }
0354  catch (System.Data.SqlClient.SqlException e)
0355  {
0356  tx.Rollback();
0357  throw e;
0358  }
0359  catch (Exception e)
0360  {
0361  tx.Rollback();
0362  throw e;
0363  }
0364  }
0365  }
0366  /// <summary>
0367  /// 执行多条SQL语句,实现数据库事务。
0368  /// </summary>
0369  /// <param name="SQLStringList">多条SQL语句</param>
0370  public static int ExecuteSqlTran(List<String> SQLStringList)
0371  {
0372  using (SqlConnection conn = new SqlConnection(connectionString))
0373  {
0374  conn.Open();
0375  SqlCommand cmd = new SqlCommand();
0376  cmd.Connection = conn;
0377  SqlTransaction tx = conn.BeginTransaction();
0378  cmd.Transaction = tx;
0379  try
0380  {
0381  int count = 0;
0382  for (int n = 0; n < SQLStringList.Count; n++)
0383  {
0384  string strsql = SQLStringList[n];
0385  if (strsql.Trim().Length > 1)
0386  {
0387  cmd.CommandText = strsql;
0388  count += cmd.ExecuteNonQuery();
0389  }
0390  }
0391  tx.Commit();
0392  return count;
0393  }
0394  catch
0395  {
0396  tx.Rollback();
0397  return 0;
0398  }
0399  }
0400  }
0401  /// <summary>
0402  /// 执行带一个存储过程参数的的SQL语句。
0403  /// </summary>
0404  /// <param name="SQLString">SQL语句</param>
0405  /// <param name="content">参数内容,比如一个字段是格式复杂的文章,有特殊符号,可以通过这个方式添加</param>
0406  /// <returns>影响的记录数</returns>
0407  public static int ExecuteSql(string SQLString, string content)
0408  {
0409  using (SqlConnection connection = new SqlConnection(connectionString))
0410  {
0411  SqlCommand cmd = new SqlCommand(SQLString, connection);
0412  System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
0413  myParameter.Value = content;
0414  cmd.Parameters.Add(myParameter);
0415  try
0416  {
0417  connection.Open();
0418  int rows = cmd.ExecuteNonQuery();
0419  return rows;
0420  }
0421  catch (System.Data.SqlClient.SqlException e)
0422  {
0423  throw e;
0424  }
0425  finally
0426  {
0427  cmd.Dispose();
0428  connection.Close();
0429  }
0430  }
0431  }
0432  /// <summary>
0433  /// 执行带一个存储过程参数的的SQL语句。
0434  /// </summary>
0435  /// <param name="SQLString">SQL语句</param>
0436  /// <param name="content">参数内容,比如一个字段是格式复杂的文章,有特殊符号,可以通过这个方式添加</param>
0437  /// <returns>影响的记录数</returns>
0438  public static object ExecuteSqlGet(string SQLString, string content)
0439  {
0440  using (SqlConnection connection = new SqlConnection(connectionString))
0441  {
0442  SqlCommand cmd = new SqlCommand(SQLString, connection);
0443  System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
0444  myParameter.Value = content;
0445  cmd.Parameters.Add(myParameter);
0446  try
0447  {
0448  connection.Open();
0449  object obj = cmd.ExecuteScalar();
0450  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0451  {
0452  return null;
0453  }
0454  else
0455  {
0456  return obj;
0457  }
0458  }
0459  catch (System.Data.SqlClient.SqlException e)
0460  {
0461  throw e;
0462  }
0463  finally
0464  {
0465  cmd.Dispose();
0466  connection.Close();
0467  }
0468  }
0469  }
0470  /// <summary>
0471  /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
0472  /// </summary>
0473  /// <param name="strSQL">SQL语句</param>
0474  /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
0475  /// <returns>影响的记录数</returns>
0476  public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
0477  {
0478  using (SqlConnection connection = new SqlConnection(connectionString))
0479  {
0480  SqlCommand cmd = new SqlCommand(strSQL, connection);
0481  System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
0482  myParameter.Value = fs;
0483  cmd.Parameters.Add(myParameter);
0484  try
0485  {
0486  connection.Open();
0487  int rows = cmd.ExecuteNonQuery();
0488  return rows;
0489  }
0490  catch (System.Data.SqlClient.SqlException e)
0491  {
0492  throw e;
0493  }
0494  finally
0495  {
0496  cmd.Dispose();
0497  connection.Close();
0498  }
0499  }
0500  }
0501  /// <summary>
0502  /// 执行一条计算查询结果语句,返回查询结果(object)。
0503  /// </summary>
0504  /// <param name="SQLString">计算查询结果语句</param>
0505  /// <returns>查询结果(object)</returns>
0506  public static object GetSingle(string SQLString)
0507  {
0508  using (SqlConnection connection = new SqlConnection(connectionString))
0509  {
0510  using (SqlCommand cmd = new SqlCommand(SQLString, connection))
0511  {
0512  try
0513  {
0514  connection.Open();
0515  object obj = cmd.ExecuteScalar();
0516  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0517  {
0518  return null;
0519  }
0520  else
0521  {
0522  return obj;
0523  }
0524  }
0525  catch (System.Data.SqlClient.SqlException e)
0526  {
0527  connection.Close();
0528  throw e;
0529  }
0530  }
0531  }
0532  }
0533  public static object GetSingle(string SQLString, int Times)
0534  {
0535  using (SqlConnection connection = new SqlConnection(connectionString))
0536  {
0537  using (SqlCommand cmd = new SqlCommand(SQLString, connection))
0538  {
0539  try
0540  {
0541  connection.Open();
0542  cmd.CommandTimeout = Times;
0543  object obj = cmd.ExecuteScalar();
0544  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0545  {
0546  return null;
0547  }
0548  else
0549  {
0550  return obj;
0551  }
0552  }
0553  catch (System.Data.SqlClient.SqlException e)
0554  {
0555  connection.Close();
0556  throw e;
0557  }
0558  }
0559  }
0560  }
0561  /// <summary>
0562  /// 执行查询语句,返回SqlDataReader ( 注意:调用该方法后,一定要对SqlDataReader进行Close )
0563  /// </summary>
0564  /// <param name="strSQL">查询语句</param>
0565  /// <returns>SqlDataReader</returns>
0566  public static SqlDataReader ExecuteReader(string strSQL)
0567  {
0568  SqlConnection connection = new SqlConnection(connectionString);
0569  SqlCommand cmd = new SqlCommand(strSQL, connection);
0570  try
0571  {
0572  connection.Open();
0573  SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
0574  return myReader;
0575  }
0576  catch (System.Data.SqlClient.SqlException e)
0577  {
0578  throw e;
0579  }
0580  }
0581  /// <summary>
0582  /// 执行查询语句,返回DataSet
0583  /// </summary>
0584  /// <param name="SQLString">查询语句</param>
0585  /// <returns>DataSet</returns>
0586  public static DataSet Query(string SQLString)
0587  {
0588  using (SqlConnection connection = new SqlConnection(connectionString))
0589  {
0590  DataSet ds = new DataSet();
0591  try
0592  {
0593  connection.Open();
0594  SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
0595  command.Fill(ds, "ds");
0596  }
0597  catch (System.Data.SqlClient.SqlException ex)
0598  {
0599  throw new Exception(ex.Message);
0600  }
0601  return ds;
0602  }
0603  }
0604  /// <summary>
0605  /// 查询并得到数据集DataSet
0606  /// </summary>
0607  /// <param name="SQLString"></param>
0608  /// <param name="Times"></param>
0609  /// <returns></returns>
0610  public static DataSet Query(string SQLString, int Times)
0611  {
0612  using (SqlConnection connection = new SqlConnection(connectionString))
0613  {
0614  DataSet ds = new DataSet();
0615  try
0616  {
0617  connection.Open();
0618  SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
0619  command.SelectCommand.CommandTimeout = Times;
0620  command.Fill(ds, "ds");
0621  }
0622  catch (System.Data.SqlClient.SqlException ex)
0623  {
0624  throw new Exception(ex.Message);
0625  }
0626  return ds;
0627  }
0628  }
0629  #endregion
0630  #region 执行带参数的SQL语句
0631  /// <summary>
0632  /// 执行SQL语句,返回影响的记录数
0633  /// </summary>
0634  /// <param name="SQLString">SQL语句</param>
0635  /// <returns>影响的记录数</returns>
0636  public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
0637  {
0638  using (SqlConnection connection = new SqlConnection(connectionString))
0639  {
0640  using (SqlCommand cmd = new SqlCommand())
0641  {
0642  try
0643  {
0644  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
0645  int rows = cmd.ExecuteNonQuery();
0646  cmd.Parameters.Clear();
0647  return rows;
0648  }
0649  catch (System.Data.SqlClient.SqlException e)
0650  {
0651  throw e;
0652  }
0653  }
0654  }
0655  }
0656  /// <summary>
0657  /// 执行多条SQL语句,实现数据库事务。
0658  /// </summary>
0659  /// <param name="SQLStringList">SQL语句的哈希表(key为sql语句,value是该语句的SqlParameter[])</param>
0660  public static void ExecuteSqlTran(Hashtable SQLStringList)
0661  {
0662  using (SqlConnection conn = new SqlConnection(connectionString))
0663  {
0664  conn.Open();
0665  using (SqlTransaction trans = conn.BeginTransaction())
0666  {
0667  SqlCommand cmd = new SqlCommand();
0668  try
0669  {
0670  //循环
0671  foreach (DictionaryEntry myDE in SQLStringList)
0672  {
0673  string cmdText = myDE.Key.ToString();
0674  SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
0675  PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
0676  int val = cmd.ExecuteNonQuery();
0677  cmd.Parameters.Clear();
0678  }
0679  trans.Commit();
0680  }
0681  catch
0682  {
0683  trans.Rollback();
0684  throw;
0685  }
0686  }
0687  }
0688  }
0689  /// <summary>
0690  /// 执行多条SQL语句,实现数据库事务。
0691  /// </summary>
0692  /// <param name="SQLStringList">SQL语句的哈希表(key为sql语句,value是该语句的SqlParameter[])</param>
0693  public static int ExecuteSqlTran(System.Collections.Generic.List<CommandInfo> cmdList)
0694  {
0695  using (SqlConnection conn = new SqlConnection(connectionString))
0696  {
0697  conn.Open();
0698  using (SqlTransaction trans = conn.BeginTransaction())
0699  {
0700  SqlCommand cmd = new SqlCommand();
0701  try
0702  {
0703  int count = 0;
0704  //循环
0705  foreach (CommandInfo myDE in cmdList)
0706  {
0707  string cmdText = myDE.CommandText;
0708  SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
0709  PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
0710  if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
0711  {
0712  if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
0713  {
0714  trans.Rollback();
0715  return 0;
0716  }
0717  object obj = cmd.ExecuteScalar();
0718  bool isHave = false;
0719  if (obj == null && obj == DBNull.Value)
0720  {
0721  isHave = false;
0722  }
0723  isHave = Convert.ToInt32(obj) > 0;
0724  if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
0725  {
0726  trans.Rollback();
0727  return 0;
0728  }
0729  if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
0730  {
0731  trans.Rollback();
0732  return 0;
0733  }
0734  continue;
0735  }
0736  int val = cmd.ExecuteNonQuery();
0737  count += val;
0738  if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
0739  {
0740  trans.Rollback();
0741  return 0;
0742  }
0743  cmd.Parameters.Clear();
0744  }
0745  trans.Commit();
0746  return count;
0747  }
0748  catch
0749  {
0750  trans.Rollback();
0751  throw;
0752  }
0753  }
0754  }
0755  }
0756  /// <summary>
0757  /// 执行多条SQL语句,实现数据库事务。
0758  /// </summary>
0759  /// <param name="SQLStringList">SQL语句的哈希表(key为sql语句,value是该语句的SqlParameter[])</param>
0760  public static void ExecuteSqlTranWithIndentity(System.Collections.Generic.List<CommandInfo> SQLStringList)
0761  {
0762  using (SqlConnection conn = new SqlConnection(connectionString))
0763  {
0764  conn.Open();
0765  using (SqlTransaction trans = conn.BeginTransaction())
0766  {
0767  SqlCommand cmd = new SqlCommand();
0768  try
0769  {
0770  int indentity = 0;
0771  //循环
0772  foreach (CommandInfo myDE in SQLStringList)
0773  {
0774  string cmdText = myDE.CommandText;
0775  SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
0776  foreach (SqlParameter q in cmdParms)
0777  {
0778  if (q.Direction == ParameterDirection.InputOutput)
0779  {
0780  q.Value = indentity;
0781  }
0782  }
0783  PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
0784  int val = cmd.ExecuteNonQuery();
0785  foreach (SqlParameter q in cmdParms)
0786  {
0787  if (q.Direction == ParameterDirection.Output)
0788  {
0789  indentity = Convert.ToInt32(q.Value);
0790  }
0791  }
0792  cmd.Parameters.Clear();
0793  }
0794  trans.Commit();
0795  }
0796  catch
0797  {
0798  trans.Rollback();
0799  throw;
0800  }
0801  }
0802  }
0803  }
0804  /// <summary>
0805  /// 执行多条SQL语句,实现数据库事务。
0806  /// </summary>
0807  /// <param name="SQLStringList">SQL语句的哈希表(key为sql语句,value是该语句的SqlParameter[])</param>
0808  public static void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
0809  {
0810  using (SqlConnection conn = new SqlConnection(connectionString))
0811  {
0812  conn.Open();
0813  using (SqlTransaction trans = conn.BeginTransaction())
0814  {
0815  SqlCommand cmd = new SqlCommand();
0816  try
0817  {
0818  int indentity = 0;
0819  //循环
0820  foreach (DictionaryEntry myDE in SQLStringList)
0821  {
0822  string cmdText = myDE.Key.ToString();
0823  SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
0824  foreach (SqlParameter q in cmdParms)
0825  {
0826  if (q.Direction == ParameterDirection.InputOutput)
0827  {
0828  q.Value = indentity;
0829  }
0830  }
0831  PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
0832  int val = cmd.ExecuteNonQuery();
0833  foreach (SqlParameter q in cmdParms)
0834  {
0835  if (q.Direction == ParameterDirection.Output)
0836  {
0837  indentity = Convert.ToInt32(q.Value);
0838  }
0839  }
0840  cmd.Parameters.Clear();
0841  }
0842  trans.Commit();
0843  }
0844  catch
0845  {
0846  trans.Rollback();
0847  throw;
0848  }
0849  }
0850  }
0851  }
0852  /// <summary>
0853  /// 执行一条计算查询结果语句,返回查询结果(object)。
0854  /// </summary>
0855  /// <param name="SQLString">计算查询结果语句</param>
0856  /// <returns>查询结果(object)</returns>
0857  public static object GetSingle(string SQLString, params SqlParameter[] cmdParms)
0858  {
0859  using (SqlConnection connection = new SqlConnection(connectionString))
0860  {
0861  using (SqlCommand cmd = new SqlCommand())
0862  {
0863  try
0864  {
0865  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
0866  object obj = cmd.ExecuteScalar();
0867  cmd.Parameters.Clear();
0868  if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
0869  {
0870  return null;
0871  }
0872  else
0873  {
0874  return obj;
0875  }
0876  }
0877  catch (System.Data.SqlClient.SqlException e)
0878  {
0879  throw e;
0880  }
0881  }
0882  }
0883  }
0884  /// <summary>
0885  /// 执行查询语句,返回SqlDataReader ( 注意:调用该方法后,一定要对SqlDataReader进行Close )
0886  /// </summary>
0887  /// <param name="strSQL">查询语句</param>
0888  /// <returns>SqlDataReader</returns>
0889  public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
0890  {
0891  SqlConnection connection = new SqlConnection(connectionString);
0892  SqlCommand cmd = new SqlCommand();
0893  try
0894  {
0895  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
0896  SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
0897  cmd.Parameters.Clear();
0898  return myReader;
0899  }
0900  catch (System.Data.SqlClient.SqlException e)
0901  {
0902  throw e;
0903  }
0904  //finally
0905  //{
0906  //cmd.Dispose();
0907  //connection.Close();
0908  //}
0909  }
0910  /// <summary>
0911  /// 执行查询语句,返回DataSet
0912  /// </summary>
0913  /// <param name="SQLString">查询语句</param>
0914  /// <returns>DataSet</returns>
0915  public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
0916  {
0917  using (SqlConnection connection = new SqlConnection(connectionString))
0918  {
0919  SqlCommand cmd = new SqlCommand();
0920  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
0921  using (SqlDataAdapter da = new SqlDataAdapter(cmd))
0922  {
0923  DataSet ds = new DataSet();
0924  try
0925  {
0926  da.Fill(ds, "ds");
0927  cmd.Parameters.Clear();
0928  }
0929  catch (System.Data.SqlClient.SqlException ex)
0930  {
0931  throw new Exception(ex.Message);
0932  }
0933  return ds;
0934  }
0935  }
0936  }
0937  private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
0938  {
0939  if (conn.State != ConnectionState.Open)
0940  conn.Open();
0941  cmd.Connection = conn;
0942  cmd.CommandText = cmdText;
0943  if (trans != null)
0944  cmd.Transaction = trans;
0945  cmd.CommandType = CommandType.Text;//cmdType;
0946  if (cmdParms != null)
0947  {
0948  foreach (SqlParameter parameter in cmdParms)
0949  {
0950  if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
0951  (parameter.Value == null))
0952  {
0953  parameter.Value = DBNull.Value;
0954  }
0955  cmd.Parameters.Add(parameter);
0956  }
0957  }
0958  }
0959  #endregion
0960  #region 存储过程操作
0961  /// <summary>
0962  /// 执行存储过程,返回SqlDataReader ( 注意:调用该方法后,一定要对SqlDataReader进行Close )
0963  /// </summary>
0964  /// <param name="storedProcName">存储过程名</param>
0965  /// <param name="parameters">存储过程参数</param>
0966  /// <returns>SqlDataReader</returns>
0967  public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
0968  {
0969  SqlConnection connection = new SqlConnection(connectionString);
0970  SqlDataReader returnReader;
0971  connection.Open();
0972  SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
0973  command.CommandType = CommandType.StoredProcedure;
0974  returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
0975  return returnReader;
0976  }
0977  /// <summary>
0978  /// 执行存储过程
0979  /// </summary>
0980  /// <param name="storedProcName">存储过程名</param>
0981  /// <param name="parameters">存储过程参数</param>
0982  /// <param name="tableName">DataSet结果中的表名</param>
0983  /// <returns>DataSet</returns>
0984  public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
0985  {
0986  using (SqlConnection connection = new SqlConnection(connectionString))
0987  {
0988  DataSet dataSet = new DataSet();
0989  connection.Open();
0990  SqlDataAdapter sqlDA = new SqlDataAdapter();
0991  sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
0992  sqlDA.Fill(dataSet, tableName);
0993  connection.Close();
0994  return dataSet;
0995  }
0996  }
0997  public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
0998  {
0999  using (SqlConnection connection = new SqlConnection(connectionString))
1000  {
1001  DataSet dataSet = new DataSet();
1002  connection.Open();
1003  SqlDataAdapter sqlDA = new SqlDataAdapter();
1004  sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
1005  sqlDA.SelectCommand.CommandTimeout = Times;
1006  sqlDA.Fill(dataSet, tableName);
1007  connection.Close();
1008  return dataSet;
1009  }
1010  }
1011  /// <summary>
1012  /// 构建 SqlCommand 对象(用来返回一个结果集,而不是一个整数值)
1013  /// </summary>
1014  /// <param name="connection">数据库连接</param>
1015  /// <param name="storedProcName">存储过程名</param>
1016  /// <param name="parameters">存储过程参数</param>
1017  /// <returns>SqlCommand</returns>
1018  private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
1019  {
1020  SqlCommand command = new SqlCommand(storedProcName, connection);
1021  command.CommandType = CommandType.StoredProcedure;
1022  foreach (SqlParameter parameter in parameters)
1023  {
1024  if (parameter != null)
1025  {
1026  // 检查未分配值的输出参数,将其分配以DBNull.Value.
1027  if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
1028  (parameter.Value == null))
1029  {
1030  parameter.Value = DBNull.Value;
1031  }
1032  command.Parameters.Add(parameter);
1033  }
1034  }
1035  return command;
1036  }
1037  /// <summary>
1038  /// 执行存储过程,返回影响的行数
1039  /// </summary>
1040  /// <param name="storedProcName">存储过程名</param>
1041  /// <param name="parameters">存储过程参数</param>
1042  /// <param name="rowsAffected">影响的行数</param>
1043  /// <returns></returns>
1044  public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
1045  {
1046  using (SqlConnection connection = new SqlConnection(connectionString))
1047  {
1048  int result;
1049  connection.Open();
1050  SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
1051  rowsAffected = command.ExecuteNonQuery();
1052  result = (int)command.Parameters["ReturnValue"].Value;
1053  //Connection.Close();
1054  return result;
1055  }
1056  }
1057  /// <summary>
1058  /// 创建 SqlCommand 对象实例(用来返回一个整数值)
1059  /// </summary>
1060  /// <param name="storedProcName">存储过程名</param>
1061  /// <param name="parameters">存储过程参数</param>
1062  /// <returns>SqlCommand 对象实例</returns>
1063  private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
1064  {
1065  SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
1066  command.Parameters.Add(new SqlParameter("ReturnValue",
1067  SqlDbType.Int, 4, ParameterDirection.ReturnValue,
1068  false, 0, 0, string.Empty, DataRowVersion.Default, null));
1069  return command;
1070  }
1071  #endregion
1072  }
1073

你可能感兴趣的:(help)