sqlbasic.cs

企业内部的短信交流管理平台。 设计详细

using System;
using System.Data;
using System.Web;
using System.Data.SqlClient;
using System.Collections;

namespace Com.SMS.Dal
{
	/// <summary>
	/// SqlBasic 的摘要说明。
	/// </summary>
	public abstract class SqlBasic
	{
		/// <summary>
		/// 连接字符串
		/// </summary>
		public static readonly string CONN_STRING =System.Configuration.ConfigurationSettings.AppSettings["MyDBCon"];
        


		// 用户缓存参数。
		private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());


		/// <summary>
		/// 
		/// </summary>
		/// <param name="connString"></param>
		/// <param name="cmdType"></param>
		/// <param name="cmdText"></param>
		/// <param name="dt"></param>
		/// <param name="cmdParms"></param>
		public static void FillDatatable(string connString, CommandType cmdType, string cmdText, DataTable dt, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			using (SqlConnection conn = new SqlConnection(connString))
			{
				PrepareCommand(cmd,conn,null,cmdType,cmdText,cmdParms);
				SqlDataAdapter ada = new SqlDataAdapter(cmd);
				ada.Fill(dt);
				cmd.Parameters.Clear();
			}
		}

		/// <summary>
		/// 执行一个sql命令，仅仅返回数据库受影响行数。
		/// 所需参数：连接字符串，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="connString">连接字符串</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>数据库受影响行数</returns>
		public static int ExecuteNonQuery(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			using (SqlConnection conn = new SqlConnection(connString))
			{
				PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
				int val = cmd.ExecuteNonQuery();
				cmd.Parameters.Clear();
				return val;
			}
		}

		/// <summary>
		/// 执行一个sql命令，仅仅返回数据库受影响行数。
		/// 所需参数：连接对象，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="conn">连接对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>数据库受影响行数</returns>
		public static int ExecuteNonQuery(SqlConnection conn, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
			int val = cmd.ExecuteNonQuery();
			cmd.Parameters.Clear();
			return val;
		}

		/// <summary>
		/// 执行一个sql命令，仅仅返回数据库受影响行数。(用于需要事务的情况)
		/// 所需参数：事务对象，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="trans">事务对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>数据库受影响行数</returns>
		public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();
			PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);
			int val = cmd.ExecuteNonQuery();
			cmd.Parameters.Clear();
			return val;
		}
        
		/// <summary>
		/// 执行一个sql查询语句，返回DataReader对象。使用默认连接。
		/// 所需参数：命令文本，参数列表。
		/// </summary>
		/// <param name="cmdText"></param>
		/// <param name="cmdParms"></param>
		/// <returns></returns>
		public static SqlDataReader ExecuteReader(string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();
			SqlConnection conn = new SqlConnection(CONN_STRING);

			// 此处使用try/catch的原因：当出现异常时，也可以保证能关闭连接。
			try
			{
				PrepareCommand(cmd, conn, null, CommandType.Text, cmdText, cmdParms);
				SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
				cmd.Parameters.Clear();
				return rdr;
			}
			catch
			{
				conn.Close();
				throw;
			}
		}

		/// <summary>
		/// 执行一个sql查询语句，返回DataReader对象。使用默认连接。
		/// </summary>
		/// <param name="trans"></param>
		/// <param name="cmdType"></param>
		/// <param name="cmdText"></param>
		/// <param name="cmdParms"></param>
		/// <returns></returns>
		public static SqlDataReader ExecuteReader(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();
			try
			{
				PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);
				SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
				cmd.Parameters.Clear();
				return rdr;
			}
			catch(Exception ee)
			{
				Exception ex=ee;
				throw ex;
			}
		}

		/// <summary>
		/// 执行一个sql查询命令，返回DataReader对象。
		/// 所需参数：连接字符串，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="connString">连接字符串</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>查询的结果 DataReader对象</returns>
		public static SqlDataReader ExecuteReader(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();
			SqlConnection conn = new SqlConnection(connString);

			// 此处使用try/catch的原因：当出现异常时，也可以保证能关闭连接。
			try
			{
				PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
				SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
				cmd.Parameters.Clear();
				return rdr;
			}
			catch(Exception ee)
			{
				conn.Close();
				throw ee;
			}
		}
		/// <summary>
		/// 执行一个sql查询命令，返回DataReader对象。
		/// 所需参数：连接对象，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="conn">连接对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns></returns>
		public static SqlDataReader ExecuteReader(SqlConnection conn, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
			SqlDataReader rdr = cmd.ExecuteReader();
			cmd.Parameters.Clear();
			return rdr;
		}

		/// <summary>
		/// 执行一个sql查询命令，返回查询结果的第一行第一列的值。
		/// 所需参数：连接字符串，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="connString">连接字符串</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>查询结果的第一行第一列的值</returns>
		public static object ExecuteScalar(string connString, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			using (SqlConnection conn = new SqlConnection(connString))
			{
				PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
				object val = cmd.ExecuteScalar();
				cmd.Parameters.Clear();
				return val;
			}
		}
		/// <summary>
		/// 执行一个sql查询命令，返回查询结果的第一行第一列的值。
		/// 所需参数：连接对象，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="conn">连接对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>查询结果的第一行第一列的值</returns>
		public static object ExecuteScalar(SqlConnection conn, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
			object val = cmd.ExecuteScalar();
			cmd.Parameters.Clear();
			return val;

		}
		/// <summary>
		/// 执行一个sql查询命令，返回查询结果的第一行第一列的值, 支持事务。
		/// 所需参数：连接对象，命令类型，命令文本，参数列表。
		/// </summary>
		/// <param name="conn">连接对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		/// <returns>查询结果的第一行第一列的值</returns>
		public static object ExecuteScalar(SqlTransaction tran, CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
		{
			SqlCommand cmd = new SqlCommand();

			PrepareCommand(cmd, tran.Connection, tran, cmdType, cmdText, cmdParms);
			object val = cmd.ExecuteScalar();
			cmd.Parameters.Clear();
			return val;

		}

		/// <summary>
		/// 缓存一个参数数组。
		/// </summary>
		/// <param name="cacheKey">参数数组在缓存中的名称</param>
		/// <param name="cmdParms">参数数组</param>
		public static void SetCacheParameters(string cacheKey, params SqlParameter[] cmdParms)
		{
			parmCache[cacheKey] = cmdParms;
		}

		/// <summary>
		/// 从缓存中获取一个参数数组。
		/// </summary>
		/// <param name="cacheKey">参数数组在缓存中的名称</param>
		/// <returns>参数数组的副本</returns>
		public static SqlParameter[] GetCachedParameters(string cacheKey)
		{
			SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

			if (cachedParms == null)
				return null;

			//克隆一个参数数组的原因：此处的操作会对获取的参数进行赋值操作。
			SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

			for (int i = 0, j = cachedParms.Length; i < j; i++)
				clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

			return clonedParms;
		}

		/// <summary>
		/// 准备一个可以执行的Sql命令对象。
		/// </summary>
		/// <param name="cmd">命令对象</param>
		/// <param name="conn">连接对象</param>
		/// <param name="trans">事务对象</param>
		/// <param name="cmdType">命令类型</param>
		/// <param name="cmdText">命令文本</param>
		/// <param name="cmdParms">参数列表</param>
		private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
		{

			if (conn.State != ConnectionState.Open)
				conn.Open();

			cmd.Connection = conn;
			cmd.CommandText = cmdText;

			if (trans != null)
				cmd.Transaction = trans;

			cmd.CommandType = cmdType;

			if (cmdParms != null)
			{
				foreach (SqlParameter parm in cmdParms)
					cmd.Parameters.Add(parm);
			}
		}
	}
}