自己编写的数据访问类（C#）－－补充代码（3）
作者/天才　时间/2006-1-10 17:36:00　类别/开发技术 查看/
　发表评论　以论坛方式查看
标签：.Net联盟
作者：黄润成

自己编写的数据访问类（C#）－－补充代码（3）



using System;
using System.Data;
using System.Data.OleDb;
using System.Collections;
using it.com.cn.DbServices;

namespace it.com.cn.DbServices.OleDbServices
{
/// <summary>
/// OleDbServices 的摘要说明。
/// </summary>
public class OleDbService: IDbService
{
private string FConnString;
private OleDbConnection FConnection;
private OleDbCommand FCommand;
private OleDbDataAdapter FAdapter;
private OleDbCommandBuilder FCommandBuilder;
private string FErrorMessage;
private OleDbTransaction FTransaction = null;
private bool InTransaction = false;
private long FTickCount = 0;

public OleDbService()
{
try
{
FConnString = System.Configuration.ConfigurationSettings.AppSettings["ConnectionString"];
FConnection = new OleDbConnection(FConnString);
FConnection.Open();
FAdapter = new OleDbDataAdapter("", FConnection);
FCommand = FAdapter.SelectCommand;
FCommandBuilder = new OleDbCommandBuilder(FAdapter);
}
catch (Exception e)
{
throw new Exception("创建数据访问对象发生错误！\n错误信息：\n" + e.Message);
}
}

public OleDbService(string connectionString)
{
try
{
FConnString = connectionString;
FConnection = new OleDbConnection(FConnString);
FConnection.Open();
FAdapter = new OleDbDataAdapter("", FConnection);
FCommand = FAdapter.SelectCommand;
FCommandBuilder = new OleDbCommandBuilder(FAdapter);
}
catch (Exception e)
{
throw new Exception("创建数据访问对象发生错误！\n错误信息：\n" + e.Message);
}
}


#region IDbService 成员

public string ConnectionString
{
get
{
return FConnString;
}
set
{
FConnString = value;
try
{
FConnection.Close();
FConnection.ConnectionString = FConnString;
FConnection.Open();
}
catch (Exception e)
{
FErrorMessage = "设置数据库连接串时发生错误！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}
}

public string ErrorMessage
{
get
{
return FErrorMessage;
}
}

public ConnectionState State
{
get
{
return FConnection.State;
}
}

public long TickCount
{
get
{
return FTickCount;
}
}

public IDbDataParameter CreateParameter(string ParamName, DbType ParamType)
{
return (IDbDataParameter) new OleDbParameter(ParamName, ParamType);
}


public IDbDataParameter CreateParameter(string ParamName, DbType ParamType, object ParamValue)
{
OleDbParameter Param = new OleDbParameter(ParamName, ParamType);
Param.Value = ParamValue;
return (IDbDataParameter) Param;
}


public IDbDataParameter CreateParameter(string ParamName, DbType ParamType, object ParamValue, ParameterDirection ParamDirection)
{
OleDbParameter Param = (OleDbParameter) CreateParameter(ParamName, ParamType, ParamValue);
Param.Direction = ParamDirection;
return (IDbDataParameter) Param;
}


public DbParams CreateDbParams(string[] ParamNames, DbType[] ParamTypes)
{
if ( ParamNames.Length != ParamTypes.Length )
{
throw new Exception( "参数的数组长度不一致。" );
}
DbParams dbParams = new DbParams();
for (int i = 0; i < ParamNames.Length; i++)
{
dbParams.AddParam(CreateParameter(ParamNames, ParamTypes));
}
return dbParams;
}


public DbParams CreateDbParams(string[] ParamNames, System.Data.DbType[] ParamTypes, object[] ParamValues)
{
if ( ParamNames.Length != ParamTypes.Length || ParamNames.Length != ParamValues.Length )
{
throw new Exception( "参数的数组长度不一致。" );
}
DbParams dbParams = new DbParams();
for (int i = 0; i < ParamNames.Length; i++)
{
dbParams.AddParam(CreateParameter(ParamNames, ParamTypes, ParamValues));
}
return dbParams;
}


public DbParams CreateDbParams( string[] ParamNames, DbType[] ParamTypes, object[] ParamValues, ParameterDirection[] ParamDirections )
{
if ( ParamNames.Length != ParamTypes.Length || ParamNames.Length != ParamValues.Length || ParamNames.Length != ParamDirections.Length )
{
throw new Exception( "参数的数组长度不一致。" );
}
DbParams dbParams = new DbParams();
for (int i = 0; i < ParamNames.Length; i++)
{
dbParams.AddParam(CreateParameter(ParamNames, ParamTypes, ParamValues, ParamDirections));
}
return dbParams;
}


public DbParams CreateDbParams(string ParamName, DbType ParamType)
{
DbParams dbParams = new DbParams();
dbParams.AddParam(CreateParameter(ParamName, ParamType));
return dbParams;
}

public DbParams CreateDbParams(string ParamName, DbType ParamType, object ParamValue)
{
DbParams dbParams = new DbParams();
dbParams.AddParam(CreateParameter(ParamName, ParamType, ParamValue));
return dbParams;
}


public DbParams CreateDbParams(string ParamName, DbType ParamType, object ParamValue, ParameterDirection ParamDirection)
{
DbParams dbParams = new DbParams();
dbParams.AddParam(CreateParameter(ParamName, ParamType, ParamValue, ParamDirection));
return dbParams;
}


public void ExecuteProcedure(string ProcedureName, DbParams Params)
{
try
{
FCommand.CommandText = ProcedureName;
FCommand.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
FCommand.ExecuteNonQuery();
}
catch ( Exception e )
{
FErrorMessage = "执行存储过程时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public IDataReaderWrapper ExecuteProcedureReader(string ProcedureName, DbParams Params)
{
try
{
FCommand.CommandText = ProcedureName;
FCommand.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
OleDbDataReader reader = FCommand.ExecuteReader();
IDataReaderWrapper ReaderWrapper = new DataReaderWrapper(reader, this, reader.HasRows);
return ReaderWrapper;
}
catch ( Exception e )
{
FErrorMessage = "执行存储过程时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataSet ExecuteProcedureDataSet(string ProcedureName, DbParams Params)
{
try
{
FCommand.CommandText = ProcedureName;
FCommand.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet );
return ADataSet;
}
catch ( Exception e )
{
FErrorMessage = "执行存储过程时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataTable ExecuteProcedureTable(string ProcedureName, DbParams Params)
{
try
{
FCommand.CommandText = ProcedureName;
FCommand.CommandType = CommandType.StoredProcedure;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataTable ADataTable = new DataTable();
FAdapter.Fill( ADataTable );
return ADataTable;
}
catch ( Exception e )
{
FErrorMessage = "执行存储过程时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}


public DbParams ExecuteProcedureResults(string ProcedureName, DbParams Params)
{
try
{
FCommand.CommandText = ProcedureName;
FCommand.CommandType = CommandType.StoredProcedure;
DbParams Results = new DbParams();
for ( int i=0; i < Params.Count; i++ )
{
FCommand.Parameters.Add( Params );
if (( Params.Direction == ParameterDirection.Output ) || ( Params.Direction == ParameterDirection.InputOutput ))
{
Results.AddParam(Params);
}
}
FCommand.ExecuteNonQuery();
return Results;
}
catch ( Exception e )
{
FErrorMessage = "执行存储过程时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public void ExecuteNone(string SqlString)
{
ExecuteNone(SqlString, new DbParams());
}

public void ExecuteNone(string SqlString, DbParams Params)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
this.BeginTransaction();
FCommand.ExecuteNonQuery();
this.CommitTransaction();
}
catch ( Exception e )
{
this.RollbackTransaction();
FErrorMessage = "执行 SQL 语句时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public IDataReaderWrapper ExecuteReader(string SqlString)
{
return ExecuteReader(SqlString, new DbParams());
}

public IDataReaderWrapper ExecuteReader(string SqlString, DbParams Params)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
OleDbDataReader reader = FCommand.ExecuteReader();
IDataReaderWrapper ReaderWrapper = new DataReaderWrapper(reader, this, reader.HasRows);
return ReaderWrapper;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataSet ExecuteDataSet(string SqlString)
{
return ExecuteDataSet(SqlString, new DbParams());
}

public DataSet ExecuteDataSet(string SqlString, int StartRowNo, int MaxRowCount)
{
return ExecuteDataSet(SqlString, new DbParams(), StartRowNo, MaxRowCount);
}

public DataSet ExecuteDataSet(string SqlString, DbParams Params)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet );
return ADataSet;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataSet ExecuteDataSet(string SqlString, DbParams Params, int StartRowNo, int MaxRowCount)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet, StartRowNo, MaxRowCount, "MappedTable" );
return ADataSet;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataSet ExecuteDataSet(string SqlString, string TableName)
{
return ExecuteDataSet(SqlString, new DbParams(), TableName);
}

public DataSet ExecuteDataSet(string SqlString, int StartRowNo, int MaxRowCount, string TableName)
{
return ExecuteDataSet(SqlString, new DbParams(), StartRowNo, MaxRowCount, TableName);
}

public DataSet ExecuteDataSet(string SqlString, DbParams Params, string TableName)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet, TableName );
return ADataSet;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataSet ExecuteDataSet(string SqlString, DbParams Params, int StartRowNo, int MaxRowCount, string TableName)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet, StartRowNo, MaxRowCount, TableName );
return ADataSet;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataTable ExecuteDataTable(string SqlString)
{
return ExecuteDataTable(SqlString, new DbParams());
}

public DataTable ExecuteDataTable(string SqlString, int StartRowNo, int MaxRowCount)
{
return ExecuteDataTable(SqlString, new DbParams(), StartRowNo, MaxRowCount);
}

public DataTable ExecuteDataTable(string SqlString, DbParams Params)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataTable ADataTable = new DataTable();
FAdapter.Fill( ADataTable );
return ADataTable;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataTable ExecuteDataTable(string SqlString, DbParams Params, int StartRowNo, int MaxRowCount)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet, StartRowNo, MaxRowCount, "MappedTable" );
return ADataSet.Tables["MappedTable"];
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataTable ExecuteDataTable(string SqlString, string TableName)
{
return ExecuteDataTable(SqlString, new DbParams(), TableName);
}

public DataTable ExecuteDataTable(string SqlString, int StartRowNo, int MaxRowCount, string TableName)
{
return ExecuteDataTable(SqlString, new DbParams(), StartRowNo, MaxRowCount, TableName);
}

public DataTable ExecuteDataTable(string SqlString, DbParams Params, string TableName)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataTable ADataTable = new DataTable( TableName );
FAdapter.Fill( ADataTable );
return ADataTable;
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public DataTable ExecuteDataTable(string SqlString, DbParams Params, int StartRowNo, int MaxRowCount, string TableName)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
DataSet ADataSet = new DataSet();
FAdapter.Fill( ADataSet, StartRowNo, MaxRowCount, TableName );
return ADataSet.Tables[TableName];
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public object ExecuteScalar(string SqlString)
{
return ExecuteScalar(SqlString, new DbParams());
}

public object ExecuteScalar(string SqlString, DbParams Params)
{
try
{
FCommand.CommandText = SqlString;
FCommand.CommandType = CommandType.Text;
if (Params != null)
{
foreach ( IDbDataParameter param in Params )
{
FCommand.Parameters.Add( param );
}
}
return FCommand.ExecuteScalar();
}
catch ( Exception e )
{
FErrorMessage = "执行查询时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
finally
{
FCommand.Parameters.Clear();
}
}

public int UpdateDataSet(DataSet ADataSet, string SqlString)
{
if (ADataSet == null)
{
FErrorMessage = "传入的 DataSet 对象为空!";
return -1;
}
try
{
FAdapter.SelectCommand.CommandText = SqlString;
int result =  FAdapter.Update(ADataSet);
ADataSet.AcceptChanges();
return result;
}
catch ( Exception e )
{
FErrorMessage = "提交 DataSet 数据时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public int UpdateDataSet(DataSet ADataSet, string SqlString, string ATableName)
{
if (ADataSet == null)
{
FErrorMessage = "传入的 DataSet 对象为空!";
return -1;
}
if (ADataSet.Tables[ATableName] == null)
{
FErrorMessage = "指定的表不在 DataSet 对象中!";
return -1;
}
try
{
FAdapter.SelectCommand.CommandText = SqlString;
int result =  FAdapter.Update(ADataSet, ATableName);
ADataSet.AcceptChanges();
return result;
}
catch ( Exception e )
{
FErrorMessage = "提交 DataSet 数据时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public int UpdateDataTable(DataTable ADataTable, string SqlString)
{
if (ADataTable == null)
{
FErrorMessage = "传入的 ADataTable 对象为空!";
return -1;
}
try
{
FAdapter.SelectCommand.CommandText = SqlString;
int result = FAdapter.Update(ADataTable);
ADataTable.AcceptChanges();
return result;
}
catch ( Exception e )
{
FErrorMessage = "提交 DataTable 数据时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public int UpdateDataRows(DataRow[] DataRows, string SqlString)
{
if (DataRows == null)
{
FErrorMessage = "传入的 DataRows 对象为空!";
return -1;
}
try
{
FAdapter.SelectCommand.CommandText = SqlString;
return FAdapter.Update(DataRows);
}
catch ( Exception e )
{
FErrorMessage = "提交 DataRows 数据时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public void BeginTransaction()
{
try
{
if (!InTransaction)
{
FTransaction = FConnection.BeginTransaction();
if ( FTransaction != null )
{
FCommand.Transaction = FTransaction;
InTransaction = true;
}
}
}
catch ( Exception e )
{
FErrorMessage = "启动事务时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public void CommitTransaction()
{
try
{
if ( InTransaction )
{
FTransaction.Commit();
InTransaction = false;
}
}
catch ( Exception e )
{
FErrorMessage = "提交事务时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public void RollbackTransaction()
{
try
{
if ( InTransaction )
{
FTransaction.Rollback();
InTransaction = false;
}
}
catch ( Exception e )
{
FErrorMessage = "回滚事务时出错！\n错误信息：\n" + e.Message;
throw new Exception(FErrorMessage);
}
}

public void Close()
{
if (FConnection.State == ConnectionState.Open)
FConnection.Close();
FTickCount = 0;
}

public void Open()
{
if (FConnection.State == ConnectionState.Closed)
                FConnection.Open();
FTickCount = 0;
}


public bool IsExists(string SqlString)
{
return IsExists(SqlString, new DbParams());
}


public bool IsExists(string SqlString, DbParams Params)
{
IDataReaderWrapper reader = ExecuteReader(SqlString, Params);
bool isExists = reader.Read();
reader.Close();
return isExists;
}


#endregion
}
}
查看该用户更多文章>>