共享Framework源代码

最新推荐文章于 2024-06-28 21:24:50 发布

iteye_20954

最新推荐文章于 2024-06-28 21:24:50 发布

阅读量73

点赞数

文章标签： SQL thread

俗话说“工欲善其事，必先利其器”，最近在做一个项目，为了省些事，索性把
以前的Framework重写了一次，没想到断断续续写了3个月之久。现在拿来出
来现现眼，请各位高手指正。

DataAccess是一个抽象基类，是其他数据访问类之母。以下正文。
using System;
using System.IO;
using System.Data;
using System.Diagnostics;

namespace TMT.Framework.Data
{
/// <summary>
/// 数据访问的抽象类：访问不同类型数据的抽象类
/// 所有访问数据相关的基类
/// </summary>
public abstract class DataAccess
{
/// <summary>
/// 构造函数
/// 空
/// </summary>
public DataAccess()
{
// Do nothing.
}

/// <summary>
/// 得到DataSet的虚方法。
/// </summary>
/// <returns></returns>
public virtual DataSet GetDataSet()
{
return new DataSet();
}

/// <summary>
/// 得到DataTable的虚方法。
/// 不是必须实装。
/// </summary>
/// <returns></returns>
public virtual DataTable GetDataTable()
{
return new DataTable();
}

/// <summary>
/// 得到DataView的虚方法。
/// </summary>
/// <returns></returns>
public virtual DataView GetDataView()
{
return new DataView();
}
}

/// <summary>
/// 数据访问类的异常类
/// </summary>
public class DataAccessException : ApplicationException
{

/// <summary>
/// 构造函数
/// </summary>
public DataAccessException()
{
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="message">信息</param>
public DataAccessException(string message) : base(message)
{
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="message">消息</param>
/// <param name="ExInner">现在异常原因以外的异常</param>
public DataAccessException(string message,Exception ExInner)
: base(message,ExInner)
{
}
}
}

/* *****************************************************************************
* Copyright (C) 2006KBA All Right Reserved。 *
* ****************************************************************************/

另外，正在做的这个项目打算做成开源的项目。

using System;
using System.Data; //for Dataset etc...
using System.Data.SqlClient; //for DataCommand etc..
using System.Configuration; //for ConfigurationSettings

using TMT.Framework.Common; //for Logger

namespace TMT.Framework.Data
{
/// <summary>
/// 数据访问类：DB访问类
/// 继承自DataAccess
/// 本类的目的
/// 1、DB访问方式的统一
/// 2、减少不良写入的风险
/// 3、提高整体Source的可读性
/// 4、减少DB访问关联的代码量
/// 5、隐藏各种DB访问对象（SqlConnection,SqlCommand,SqlDataAdapter,SqlTransaction,SqlParameter,...）
/// 解除DB访问的混乱。
/// 6、数据容器：DataReader、DataSet等，在Class里没有实现，在子类实现。
/// DataReader没有必要用New声明（通过SqlCommand.ExectueReader()同样可以实现）。
/// </summary>
public class DbAccess : DataAccess
{
//==============================================
// 连接型、非连接型共同使用的成员
//==============================================
/// <summary>
/// 连接字符串
/// </summary>
protected string connectionString;
/// <summary>
/// Connection连接对象
/// </summary>
private SqlConnection sqlConnection;
/// <summary>
/// Command命令对象
/// </summary>
private SqlCommand sqlCommand;
/// <summary>
/// Tranction事务处理对象
/// </summary>
private SqlTransaction sqlTransaction;
/// <summary>
/// 在Transaction开始，连接打开了吗？
/// </summary>
private bool isConnectionOpenAtTransaction;

//==============================================
// 非连接类型使用的成员
//==============================================
/// <summary>
/// DataAdapter
/// </summary>
private SqlDataAdapter sqlDataAdapter;
//----------------------------------------------
/// <summary>
/// 连接重试次数
/// </summary>
private int connectRetryNumber = 1;
/// <summary>
/// 连接重试间隔(毫秒)
/// </summary>
private int connectRetryInterval = 5000;
//----------------------------------------------
/// <summary>
/// 输入输出数据保存实体
/// </summary>
private DataSet dsEntity = null;
/// <summary>
/// 有无输出LOG(静态Static)
/// </summary>
static private bool isLogOutput = false;

/// ============================================
/// 属性
/// ============================================
/// <summary>
/// 命令文本（字符串）Command Text
/// </summary>
public string CommandText
{
get
{
if(sqlCommand != null)
{
return this.sqlCommand.CommandText;
}
else
{
return "";
}
}
}
/// <summary>
/// 连接重试次数（ConnectRetryNumber）
/// </summary>
protected int ConnectRetryNumber
{
get
{
return connectRetryNumber;
}
set
{
connectRetryNumber = value;
}
}
/// <summary>
/// 连接重试间隔（毫秒）
/// </summary>
protected int ConnectRetryInterval
{
get
{
return connectRetryInterval;
}
set
{
connectRetryInterval = value;
}
}
/// <summary>
/// Log输出有无
/// </summary>
static public void SetLogOutput(string isLogOutput)
{
if(isLogOutput.ToLower().Equals("true"))
{
DbAccess.isLogOutput = true;
Logger.Info(null,"DbAccess.SetLogOutput(true)...DB访问Log输出");
}
else
{
DbAccess.isLogOutput = false;
Logger.Info(null,"DvAccess.SetLogoutput(false)...DB访问Log不输出");
}
}

/// <summary>
/// 构造函数
/// </summary>
public DbAccess()
{
//成员变量初始化
this.connectionString = null;
this.sqlConnection = null;
this.sqlCommand = null;
this.sqlTransaction = null;
this.isConnectionOpenAtTransaction = false;
this.sqlDataAdapter = null;
//初始化Class的成员
this.Init();
}

/// <summary>
/// 构造函数（指定超时）
/// </summary>
/// <param name="timeoutSeconds">超时时间（秒）</param>
public DbAccess(string timeoutSeconds)
{
//成员变量初始化
this.connectionString = null;
this.sqlConnection = null;
this.sqlCommand = null;
this.sqlTransaction = null;
this.isConnectionOpenAtTransaction = false;
this.sqlDataAdapter = null;

this.Init(timeoutSeconds);
}

/// <summary>
/// 构造函数（指定超时）
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <param name="timeoutSeconds">超时时间（秒）</param>
public DbAccess(string connectionString,string timeoutSeconds)
{
this.connectionString = null;
this.sqlConnection = null;
this.sqlCommand = null;
this.sqlTransaction = null;
this.isConnectionOpenAtTransaction = false;
this.sqlDataAdapter = null;

this.Init(connectionString,timeoutSeconds);
}

/// <summary>
/// 构造函数（指定超时）
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <param name="timeoutSeconds">超时时间（秒）</param>
/// <param name="connectionRetryNumber">连接重试次数</param>
/// <param name="connectionRetryInterval">连接重试间隔</param>
public DbAccess(string connectionString,string timeoutSeconds,int connectionRetryNumber,int connectionRetryInterval)
{
this.connectionString = null;
this.sqlConnection = null;
this.sqlCommand = null;
this.sqlTransaction = null;
this.isConnectionOpenAtTransaction = false;
this.sqlDataAdapter = null;

this.Init(connectionString,timeoutSeconds,connectionRetryNumber,connectionRetryInterval);
}

/// <summary>
/// 初始化函数（不可用）
/// </summary>
protected void Init()
{
//生成Connection
this.sqlConnection = new SqlConnection(ConfigurationSettings.AppSettings["connectionString"]);
//生成SqlCommand
//作为SqlCommand，也可以作为SqlAdapeter的SqlCommand使用
this.sqlCommand = new SqlCommand();
//关联SqlCommand和SqlConnection
this.sqlCommand.Connection = this.sqlConnection;
throw new Exception("This method is not available.");
}

/// <summary>
/// 初始化函数（不可用）
/// </summary>
/// <param name="timeoutSeconds">超时时间（秒）</param>
protected void Init(string timeoutSeconds)
{
//连接字符串
string connectionString = ConfigurationSettings.AppSettings["connectionStringWithTimeout"];
//生成连接
this.sqlConnection = new SqlConnection(connectionString);
//生成SqlCommand
//作为SqlCommand，也可以作为SqlAdapeter的SqlCommand使用
this.sqlCommand = new SqlCommand();
//设置超时时间
this.sqlCommand.CommandTimeout = Int32.Parse(timeoutSeconds);
//关联SqlCommand和SqlConnection
this.sqlCommand.Connection = this.sqlConnection;

throw new Exception("This method is not available.");

}

/// <summary>
/// 初始化函数
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <param name="timeoutSeconds">超时时间（秒）</param>
protected void Init(string connectionString,string timeoutSeconds)
{
//生成连接
this.sqlConnection = new SqlConnection(connectionString);
//生成SqlCommand
//作为SqlCommand，也可以作为SqlAdapeter的SqlCommand使用
this.sqlCommand = new SqlCommand();
//设置超时时间
this.sqlCommand.CommandTimeout = Int32.Parse(timeoutSeconds);
//关联SqlCommand和SqlConnection
this.sqlCommand.Connection = this.sqlConnection;
}

/// <summary>
/// 初始化函数
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <param name="timeoutSeconds">超时时间（秒）</param>
/// <param name="connectionRetryNumber">连接重试次数</param>
/// <param name="connectionRetryInterval">连接重试间隔</param>
protected void Init(string connectionString,string timeoutSeconds,int connectionRetryNumber,int connectionRetryInterval)
{
//生成连接
this.sqlConnection = new SqlConnection(connectionString);
//生成SqlCommand
//作为SqlCommand，也可以作为SqlAdapeter的SqlCommand使用
this.sqlCommand = new SqlCommand();
//设置超时时间
this.sqlCommand.CommandTimeout = Int32.Parse(timeoutSeconds);
//设置重试次数
this.ConnectRetryNumber = connectionRetryNumber;
//设置重试间隔
this.ConnectRetryInterval = connectionRetryInterval;
//关联SqlCommand和SqlConnection
this.sqlCommand.Connection = this.sqlConnection;
}

/// <summary>
/// 打开连接
/// </summary>
/// <returns>True：打开连接成功，False：没有打开连接</returns>
public bool OpenConnection()
{
//如果Connection已经打开，do nothing
if(this.sqlConnection != null && (this.sqlConnection.State != ConnectionState.Closed))
{
return false;
}
//重试次数处理
//重试间隔处理
for(int numberOfRetry = 0;numberOfRetry <= connectRetryNumber;numberOfRetry++)
{
try
{
//打开连接
this.sqlConnection.Open();
}
catch(SqlException sql_Exception)
{
//休眠
System.Threading.Thread.Sleep(connectRetryInterval);
if(numberOfRetry == connectRetryNumber)
{
throw sql_Exception;
}
else
{
continue;
}
}
return true;
}
return false;
}

/// <summary>
/// 打开连接
/// </summary>
/// <param name="dsEntity">输入输出数据保存实体</param>
/// <returns>True：打开连接成功，False：没有打开连接</returns>
public bool OpenConnection(DataSet dsEntity)
{
this.dsEntity = dsEntity;
//如果Connection已经打开，do nothing
if(this.sqlConnection != null && (this.sqlConnection.State != ConnectionState.Closed))
{
return false;
}
//重试次数处理
//重试间隔处理
for(int numberOfRetry = 0;numberOfRetry <= connectRetryNumber;numberOfRetry++)
{
try
{
//打开连接
this.sqlConnection.Open();
}
catch(SqlException sql_exception)
{
System.Threading.Thread.Sleep(connectRetryInterval);
if(numberOfRetry == connectRetryNumber)
{
throw sql_exception;
}
else
{
continue;
}
}
return true;
}
return false;
}

/// <summary>
/// 关闭连接
/// </summary>
public void CloseConnection()
{
if(this.sqlConnection != null && (this.sqlConnection.State != ConnectionState.Closed))
{
this.sqlConnection.Close();
}
}

/// <summary>
/// 生成数据适配器
/// </summary>
private void CreateDataAdapter()
{
if(this.sqlDataAdapter == null)
{
this.sqlDataAdapter = new SqlDataAdapter();
this.sqlDataAdapter.SelectCommand = this.sqlCommand;
this.sqlDataAdapter.SelectCommand.Connection = this.sqlConnection;
}
}

/// <summary>
/// Insert/Update/Delete命令生成
///如果Update没有被设定的话，那么从Select文自动生成Insert/Update/Delete命令。
///※自动生成机能的限制
/// 1、Dataset的Table行是从一个Table派生出来的。
/// 2、在源Table，主键是被定义的。存在一个以上的列由唯一值。
/// 3、Table名字不能使用下记情形
/// >>空格（Space）
/// >>句号（.）
/// >>关键字（引用字符）
/// >>英数字以外的文字
/// 例外：如“dbo.table1”，这里的句号（.）用来修饰Table是可以的
/// </summary>
private void BuildCommand()
{

//DataAdapter未生成后者Select命令未生成的情况下，命令不能自动生成，do nothing。
if(this.sqlDataAdapter == null || this.sqlDataAdapter.SelectCommand == null)
{
return;
}

//如果有一个Command没有被设定，更新各Command（Insert/Update/Delete）
if(this.sqlDataAdapter.SelectCommand == null ||
this.sqlDataAdapter.InsertCommand == null ||
this.sqlDataAdapter.DeleteCommand == null)
{
//生成CommandBuiler
SqlCommandBuilder commandBuilder = new SqlCommandBuilder(this.sqlDataAdapter);
if(this.sqlDataAdapter.InsertCommand == null)
{
this.sqlDataAdapter.InsertCommand = commandBuilder.GetInsertCommand();
}
if(this.sqlDataAdapter.UpdateCommand == null)
{
this.sqlDataAdapter.UpdateCommand = commandBuilder.GetUpdateCommand();
}
if(this.sqlDataAdapter.DeleteCommand == null)
{
this.sqlDataAdapter.DeleteCommand = commandBuilder.GetDeleteCommand();
}
}
}

/// <summary>
/// 开始事务处理（Transaction开始）
/// </summary>
public void BeginTransaction()
{
//Insert/Update/Delete命令自动生成（如果没有）
//在事务处理中（Transaction中）不能自动生成
this.BuildCommand();
//如果连接没打开，就马上打开
this.isConnectionOpenAtTransaction = this.OpenConnection();
//Transaction开始
this.sqlTransaction = this.sqlConnection.BeginTransaction();
//设置Command.Transaction属性
if(this.sqlCommand != null)
{
if(this.sqlCommand.Transaction == null)
{
this.sqlCommand.Transaction = this.sqlTransaction;
}
else
{
if(!this.sqlCommand.Transaction.Equals(this.sqlTransaction))
{
this.sqlCommand.Transaction = this.sqlTransaction;
}
}
}
}

/// <summary>
/// 开始事务处理（Transaction开始）
/// </summary>
/// <param name="isolationlevel">事务连接的锁定级别</param>
public void BeginTransaction(System.Data.IsolationLevel isolationlevel)
{
//Insert/Update/Delete命令自动生成（如果没有）
//在事务处理中（Transaction中）不能自动生成
this.BuildCommand();
//如果连接没打开，就马上打开
this.isConnectionOpenAtTransaction = this.OpenConnection();
//Transaction开始
this.sqlTransaction = this.sqlConnection.BeginTransaction(isolationlevel);
//设置Command.Transaction属性
if(this.sqlCommand != null)
{
if(this.sqlCommand.Transaction == null)
{
this.sqlCommand.Transaction = this.sqlTransaction;
}
else
{
if(!this.sqlCommand.Transaction.Equals(this.sqlTransaction))
{
this.sqlCommand.Transaction = this.sqlTransaction;
}
}
}
}

/// <summary>
/// 提交数据库事务（Commit）
/// </summary>
public void Commit()
{
//如果Transaction没有，do nothing
if(this.sqlTransaction == null)
{
return;
}
this.sqlTransaction.Commit();
this.sqlTransaction = null;
//如果是在Transaction开始时打开的连接，那么现在关闭。
if(this.isConnectionOpenAtTransaction == true)
{
this.CloseConnection();
this.isConnectionOpenAtTransaction = false;
}
}

/// <summary>
/// 事务回滚（Rollback）
/// </summary>
public void Rollback()
{
//如果Transaction没有，do nothing
if(this.sqlTransaction == null)
{
return;
}
this.sqlTransaction.Rollback();
this.sqlTransaction = null;
//如果是在Transaction开始时打开的连接，那么现在关闭。
if(this.isConnectionOpenAtTransaction == true)
{
this.CloseConnection();
this.isConnectionOpenAtTransaction = false;
}
}

/// <summary>
/// 命令设定
/// </summary>
/// <param name="commandText">命令文本</param>
protected void SetCommand(string commandText)
{
//清空已经加载的命令参数
this.sqlCommand.Parameters.Clear();
//设定命令文本
this.sqlCommand.CommandText = commandText;
//Command类型设定
if(this.CommandText.ToUpper().StartsWith("SELECT ") ||
this.CommandText.ToUpper().StartsWith("INSERT ") ||
this.CommandText.ToUpper().StartsWith("UPDATE ") ||
this.CommandText.ToUpper().StartsWith("DELETE ") ||
this.CommandText.ToUpper().StartsWith("EXEC "))
{
//文本类型Text
this.sqlCommand.CommandType = CommandType.Text;
}
else
{
//存储过程
this.sqlCommand.CommandText = CommandType.StoredProcedure.ToString();;
}
}

/// <summary>
/// 命令设定
/// </summary>
/// <param name="commandText">命令文本</param>
/// <param name="commandType">命令类型</param>
protected void SetCommand(string commandText,CommandType commandType)
{
//清空已经加载的命令参数
this.sqlCommand.Parameters.Clear();
//设定命令文本
this.sqlCommand.CommandText = commandText;
//设定命令类型
this.sqlCommand .CommandType = commandType;
}

/// <summary>
/// 加载命令参数
/// </summary>
/// <param name="parameterName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
/// <param name="size">大小</param>
/// <param name="sourceColumn">Source列</param>
protected void AddParam(string parameterName,SqlDbType sqlDbType,
int size,string sourceColumn)
{
//加载参数
this.sqlCommand.Parameters.Add(parameterName,sqlDbType,size,sourceColumn);
}

/// <summary>
/// 加载命令参数
/// 参数方向是Input
/// </summary>
/// <param name="parameterName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
/// <param name="size">大小</param>
protected void AddParam(string parameterName,SqlDbType sqlDbType,int size)
{
//加载参数
this.sqlCommand.Parameters.Add(parameterName,sqlDbType,size);
}

/// <summary>
/// 加载命令参数
/// 参数方向是Input，值是Null
/// </summary>
/// <param name="parameterName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
protected void AddParam(string parameterName,SqlDbType sqlDbType)
{
//加载参数
this.sqlCommand.Parameters.Add(parameterName,sqlDbType);
}

/// <summary>
/// 加载命令参数
/// 参数方向是Input
/// </summary>
/// <param name="parameterName">参数名</param>
/// <param name="Value">参数值</param>
protected void AddParam(string parameterName,object Value)
{
//加载参数
this.sqlCommand.Parameters.Add(parameterName,Value);
}

/// <summary>
/// 命令参数方向设定
/// </summary>
/// <param name="strParamName">参数名</param>
/// <param name="parameterDirection">方向</param>
protected void SetParamDirection(string strParamName,ParameterDirection parameterDirection)
{
if(this.sqlCommand.Parameters[strParamName] != null)
{
this.sqlCommand.Parameters[strParamName].Direction = parameterDirection;
}
}

/// <summary>
/// 命令参数方向设定
/// </summary>
/// <param name="index">参数索引</param>
/// <param name="parameterDirection">方向</param>
protected void SetParamDirection(int index,ParameterDirection parameterDirection)
{
if(this.sqlCommand.Parameters.Count >= index)
{
this.sqlCommand.Parameters[index].Direction = parameterDirection;
}
}

/// <summary>
/// 参数值设定
/// </summary>
/// <param name="strParamName">参数名</param>
/// <param name="Value">值</param>
protected void SetParamValue(string strParamName,object Value)
{
if(this.sqlCommand.Parameters[strParamName] != null)
{
this.sqlCommand.Parameters[strParamName].Value = Value;
}
}

/// <summary>
/// 参数值设定
/// </summary>
/// <param name="index">参数索引</param>
/// <param name="Value">值</param>
protected void SetParamValue(int index,object Value)
{
if(this.sqlCommand.Parameters.Count >= index)
{
this.sqlCommand.Parameters[index].Value = Value;
}
}

/// <summary>
/// 取得参数值
/// </summary>
/// <param name="strParamName">参数名</param>
/// <returns>参数值</returns>
protected object GetParamValue(string strParamName)
{
if(this.sqlCommand.Parameters[strParamName] != null &&
this.sqlCommand.Parameters[strParamName].Value != DBNull.Value)
{
return this.sqlCommand.Parameters[strParamName].Value;
}
else
{
return null;
}
}

/// <summary>
/// 取得参数值
/// </summary>
/// <param name="index">参数索引</param>
/// <returns>参数值</returns>
protected object GetParamValue(int index)
{
if(this.sqlCommand.Parameters.Count >= index &&
this.sqlCommand.Parameters[index].Value != DBNull.Value)
{
return this.sqlCommand.Parameters[index].Value;
}
else
{
return null;
}
}

/// <summary>
/// Update命令设定
/// </summary>
/// <param name="commandText">命令文本</param>
protected void SetCommandUpdate(string commandText)
{
//如果没有数据适配器，那么生成
this.CreateDataAdapter();

//Update命令生成
this.sqlDataAdapter.UpdateCommand = new SqlCommand(commandText,this.sqlConnection);

}

/// <summary>
/// 加载Update命令参数
/// 在使用Update()时，参数和DataSet内列名对应
/// 不打算更新的Paramter的sourceVersion指定未Original
/// </summary>
/// <param name="strParamName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
/// <param name="size">大小</param>
/// <param name="strSourceColumn">源（Source）列</param>
/// <param name="sourceVersion">在读入时指定的DataRowVersion</param>
protected void AddParamUpdate(string strParamName,SqlDbType sqlDbType,int iSize,string strSourceColumn,DataRowVersion sourceVersion)
{
SqlParameter param = this.sqlDataAdapter.UpdateCommand.Parameters.Add(strParamName,sqlDbType,iSize,strSourceColumn);
param.SourceVersion = sourceVersion;
}

/// <summary>
/// Insert命令设定
/// </summary>
/// <param name="commandText">命令文本</param>
protected void SetCommandInsert(string commandText)
{
//如果没有数据适配器，那么生成
this.CreateDataAdapter();
//Insert命令生成
this.sqlDataAdapter.InsertCommand = new SqlCommand(commandText,this.sqlConnection);
}

/// <summary>
/// 加载Insert命令参数
/// 在使用Update()时，参数和DataSet内列名对应
/// </summary>
/// <param name="strParamName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
/// <param name="size">大小</param>
/// <param name="strSourceColumn">源（Source）列</param>
protected void AddParamInsert(string strParamName,SqlDbType sqlDbType,int iSize,string strSourceColumn)
{
this.sqlDataAdapter.InsertCommand.Parameters.Add(strParamName,sqlDbType,iSize,strSourceColumn);
}

/// <summary>
/// Delete命令设定
/// </summary>
/// <param name="commandText">命令文本</param>
protected void AddParamDatele(string commandText)
{
//如果没有数据适配器，那么生成
this.CreateDataAdapter();
//Insert命令生成
this.sqlDataAdapter.DeleteCommand = new SqlCommand(commandText,this.sqlConnection);
}

/// <summary>
/// 加载Delete命令参数
/// 在使用Update()时，参数和DataSet内列名对应
/// </summary>
/// <param name="strParamName">参数名</param>
/// <param name="sqlDbType">DB类型</param>
/// <param name="size">大小</param>
/// <param name="strSourceColumn">源（Source）列</param>
protected void AddParamDelete(string strParamName,SqlDbType sqlDbType,int iSize,string strSourceColumn)
{
this.sqlDataAdapter.DeleteCommand.Parameters.Add(strParamName,sqlDbType,iSize,strSourceColumn);
}

/// <summary>
/// ExcuteReader
/// </summary>
/// <param name="behavior">命令执行时的行为</param>
/// <returns>命令返回值（DataReader）</returns>
protected SqlDataReader ExecuteReader(CommandBehavior behavior)
{
//ExecuteReader自己Open，不必Close。
//因为DataReader是连接型，关闭后不能读取数据。
SqlDataReader dataReader = null;
try
{
//输出log4net日志文件
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteReader Start -- " + this.sqlCommand.CommandText);
}
dataReader = this.sqlCommand.ExecuteReader(behavior);
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteReader End");
}
}
return dataReader;
}

/// <summary>
/// ExecuteReader
/// </summary>
/// <returns>命令返回值（Datareader）</returns>
protected SqlDataReader ExecuteReader()
{
return this.sqlCommand.ExecuteReader(CommandBehavior.Default);
}

/// <summary>
/// ExecuteScalar
/// </summary>
/// <returns>命令返回值</returns>
protected object ExecuteScalar()
{
object cell = null;
try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteSaclar Start -- " + this.sqlCommand.CommandText);
}
cell = this.sqlCommand.ExecuteScalar();
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteScaler End");
}
}
return cell;
}

/// <summary>
/// ExecuteNonQuery
/// Command.ExecuteNonQuery的覆盖函数
/// </summary>
/// <returns>影响函数</returns>
protected int ExecuteNonQuery()
{
int affectedRowNum = 0;

try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteNonQuery Start -- " + this.sqlCommand.CommandText);
}
affectedRowNum = this.sqlCommand.ExecuteNonQuery();
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteNonQuery End");
}
}
return affectedRowNum;
}

/// <summary>
/// ExecuteNonQueryWithSkip
/// Command.ExecuteNonQuery的覆盖函数
/// </summary>
/// <returns>影响行数</returns>
protected int ExecuteNonQueryWithSkip()
{
int affectedRowNum = 0;
try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteNonQueryWithSkip Start -- " + this.sqlCommand.CommandText);
}
affectedRowNum = this.sqlCommand.ExecuteNonQuery();
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB ExecuteNonQueryWithSkip End");
}
}
return affectedRowNum;
}

/// <summary>
/// 填充DataSet Fill
/// SqlDataAdapter.Fill()的覆盖函数
/// </summary>
/// <param name="dataSet">将要填充的DataSet</param>
/// <param name="startRecord">开始行索引</param>
/// <param name="maxRecords">最大行数</param>
/// <param name="srcTable">填充Table名</param>
/// <returns>正常追加或更新的行数</returns>
protected int Fill(DataSet dataSet,int startRecord,int maxRecords,string srcTable)
{
this.CreateDataAdapter();
int rowNum = 0;
try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill Start -- " + this.sqlCommand.CommandText);
}
rowNum = this.sqlDataAdapter.Fill(dataSet,startRecord,maxRecords,srcTable);
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill End");
}
}
return rowNum;
}

/// <summary>
/// 填充DataSet Fill
/// SqlDataAdapter.Fill()的覆盖函数
/// </summary>
/// <param name="dataSet">将要填充的DataSet</param>
/// <param name="srcTable">填充Table名</param>
/// <returns>正常追加或更新的行数</returns>
protected int Fill(DataSet dataSet,string srcTable)
{
return this.Fill(dataSet,0,0x7FFFFFFF,srcTable);
}

/// <summary>
/// 填充DataSet Fill
/// SqlDataAdapter.Fill()的覆盖函数
/// </summary>
/// <param name="dataSet">将要填充的DataSet</param>
/// <returns>正常追加或更新的行数</returns>
protected int Fill(DataSet dataSet)
{
this.CreateDataAdapter();
int rowNum = 0;
try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill Start -- " + this.sqlCommand.CommandText);
}
rowNum = this.sqlDataAdapter.Fill(dataSet);
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill End");
}
}
return rowNum;
}

/// <summary>
/// 填充DataTable Fill
/// </summary>
/// <param name="dataTable">>将要填充的Table</param>
/// <returns>正常追加或更新的行数</returns>
protected int Fill(DataTable dataTable)
{
this.CreateDataAdapter();
int rowNum;
try
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill Start -- " + this.sqlCommand.CommandText);
}
rowNum = this.sqlDataAdapter.Fill(dataTable);
}
catch(SqlException sqlexception)
{
throw sqlexception;
}
catch(Exception exception)
{
throw exception;
}
finally
{
if(isLogOutput == true)
{
Logger.Debug(dsEntity,"DB Fill End");
}
}
return rowNum;
}

/// <summary>
/// Update
/// SqlDataAdapter.Update()的覆盖函数
/// 反映DataSet内容到DB
/// 通过使用DataSet追加、删除、变更Record，全部使用Update方法
/// </summary>
/// <param name="dataSet">数据集</param>
/// <param name="srcTable">被填充的Table名</param>
/// <returns>正常追加/更新的行数</returns>
protected int Update(DataSet dataSet,string srcTable)
{
int rowNum = 0;
if(this.sqlDataAdapter == null)
{
return rowNum;
}
this.BuildCommand();
if(this.sqlTransaction == null)
{
this.sqlDataAdapter.UpdateCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.InsertCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.DeleteCommand.Transaction = this.sqlTransaction;
}
try
{
Logger.Debug(dsEntity,"DB Update Start --" + this.sqlCommand.CommandText);
rowNum = this.sqlDataAdapter.Update(dataSet,srcTable);
}
catch(SqlException sqlException)
{
throw sqlException;
}
catch(Exception exception)
{
throw exception;
}
finally
{
Logger.Debug(dsEntity,"DB Update End");
}
return rowNum;
}
/// <summary>
/// Update
/// SqlDataAdapter.Update()的覆盖函数
/// 反映DataSet内容到DB
/// 通过使用DataSet追加、删除、变更Record，全部使用Update方法
/// </summary>
/// <param name="dataTable">被填充的Table</param>
/// <returns>正常追加/更新的行数</returns>
protected int Update(DataTable dataTable)
{
int rowNum = 0;
if(this.sqlDataAdapter == null)
{
return rowNum;
}
this.BuildCommand();
if(this.sqlTransaction == null)
{
this.sqlDataAdapter.UpdateCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.InsertCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.DeleteCommand.Transaction = this.sqlTransaction;
}
try
{
Logger.Debug(dsEntity,"DB Update Start --" + this.sqlCommand.CommandText);
rowNum = this.sqlDataAdapter.Update(dataTable);
}
catch(SqlException sqlException)
{
throw sqlException;
}
catch(Exception exception)
{
throw exception;
}
finally
{
Logger.Debug(dsEntity,"DB Update End");
}
return rowNum;
}

/// <summary>
/// Update
/// SqlDataAdapter.Update()的覆盖函数
/// 反映DataSet内容到DB
/// 通过使用DataSet追加、删除、变更Record，全部使用Update方法
/// </summary>
/// <param name="dataRow">被填充的dataRow</param>
/// <returns>正常追加/更新的行数</returns>
protected int Update(DataRow[] dataRow)
{
int rowNum = 0;
if(this.sqlDataAdapter == null)
{
return rowNum;
}
this.BuildCommand();
if(this.sqlTransaction == null)
{
this.sqlDataAdapter.UpdateCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.InsertCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.DeleteCommand.Transaction = this.sqlTransaction;
}
try
{
Logger.Debug(dsEntity,"DB Update Start --" + this.sqlCommand.CommandText);
rowNum = this.sqlDataAdapter.Update(dataRow);
}
catch(SqlException sqlException)
{
throw sqlException;
}
catch(Exception exception)
{
throw exception;
}
finally
{
Logger.Debug(dsEntity,"DB Update End");
}
return rowNum;
}

/// <summary>
/// Update
/// SqlDataAdapter.Update()的覆盖函数
/// 反映DataSet内容到DB
/// 通过使用DataSet追加、删除、变更Record，全部使用Update方法
/// </summary>
/// <param name="dataSet">被填充的dataSet</param>
/// <returns>正常追加/更新的行数</returns>
protected int Update(DataSet dataSet)
{
int rowNum = 0;
if(this.sqlDataAdapter == null)
{
return rowNum;
}
this.BuildCommand();
if(this.sqlTransaction == null)
{
this.sqlDataAdapter.UpdateCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.InsertCommand.Transaction = this.sqlTransaction;
this.sqlDataAdapter.DeleteCommand.Transaction = this.sqlTransaction;
}
try
{
Logger.Debug(dsEntity,"DB Update Start --" + this.sqlCommand.CommandText);
rowNum = this.sqlDataAdapter.Update(dataSet);
}
catch(SqlException sqlException)
{
throw sqlException;
}
catch(Exception exception)
{
throw exception;
}
finally
{
Logger.Debug(dsEntity,"DB Update End");
}
return rowNum;
}
}

/// <summary>
/// DB访问异常
/// </summary>
public class DbAccessException : DataAccessException
{

/// <summary>
/// 构造函数
/// </summary>
public DbAccessException()
{
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="message"></param>
public DbAccessException(string message)
:base(message)
{
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="message"></param>
/// <param name="inner"></param>
public DbAccessException(string message,Exception inner)
:base(message,inner)
{
}
}
}

/* ****************************************************************************
* Copyright (C) 2006KBA All Right Reserved。*
* ****************************************************************************/