public virtual IDataReader ExecuteReader(
DbCommand command,
DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(this.DoExecuteReader(command, CommandBehavior.Default));
}
public virtual async Task <DbDataReader> ExecuteReaderAsync(
DbCommand command,
DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(await this.DoExecuteReaderAsync(command, CommandBehavior.CloseConnection));
}
public virtual int ExecuteNonQuery(DbCommand command)
{
using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection())
{
Database.PrepareCommand(command, openConnection.Connection);
return(this.DoExecuteNonQuery(command));
}
}
public virtual async Task <int> ExecuteNonQueryAsync(DbCommand command)
{
using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync())
{
Database.PrepareCommand(command, openConnection.Connection);
return(await this.DoExecuteNonQueryAsync(command));
}
}
public virtual void LoadDataSet(DbCommand command, DataSet dataSet, string[] tableNames)
{
using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection())
{
Database.PrepareCommand(command, openConnection.Connection);
this.DoLoadDataSet((IDbCommand)command, dataSet, tableNames);
}
}
public virtual IDataReader ExecuteReader(DbCommand command)
{
using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection())
{
Database.PrepareCommand(command, openConnection.Connection);
IDataReader innerReader = this.DoExecuteReader(command, CommandBehavior.Default);
return(this.CreateWrappedReader(openConnection, innerReader));
}
}
public virtual void LoadDataSet(
DbCommand command,
DataSet dataSet,
string[] tableNames,
DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
this.DoLoadDataSet((IDbCommand)command, dataSet, tableNames);
}
public virtual async Task <DbDataReader> ExecuteReaderAsync(DbCommand command)
{
using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync())
{
Database.PrepareCommand(command, openConnection.Connection);
DbDataReader innerReader = await this.DoExecuteReaderAsync(command, CommandBehavior.CloseConnection);
return(this.CreateWrappedReaderForAsync(openConnection, innerReader));
}
}
public virtual async Task <object> ExecuteScalarAsync(DbCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync())
{
Database.PrepareCommand(command, openConnection.Connection);
return(await this.DoExecuteScalarAsync(command));
}
}
public virtual object ExecuteScalar(DbCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection())
{
Database.PrepareCommand(command, openConnection.Connection);
return(this.DoExecuteScalar((IDbCommand)command));
}
}
protected static void PrepareCommand(DbCommand command, DbTransaction transaction)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
Database.PrepareCommand(command, transaction.Connection);
command.Transaction = transaction;
}
public int UpdateDataSet(
DataSet dataSet,
string tableName,
DbCommand insertCommand,
DbCommand updateCommand,
DbCommand deleteCommand,
UpdateBehavior updateBehavior,
int?updateBatchSize)
{
using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection())
{
if (updateBehavior == UpdateBehavior.Transactional && Transaction.Current == (Transaction)null)
{
DbTransaction transaction = Database.BeginTransaction(openConnection.Connection);
try
{
int num = this.UpdateDataSet(dataSet, tableName, insertCommand, updateCommand, deleteCommand, transaction, updateBatchSize);
Database.CommitTransaction((IDbTransaction)transaction);
return(num);
}
catch
{
Database.RollbackTransaction((IDbTransaction)transaction);
throw;
}
}
else
{
if (insertCommand != null)
{
Database.PrepareCommand(insertCommand, openConnection.Connection);
}
if (updateCommand != null)
{
Database.PrepareCommand(updateCommand, openConnection.Connection);
}
if (deleteCommand != null)
{
Database.PrepareCommand(deleteCommand, openConnection.Connection);
}
return(this.DoUpdateDataSet(updateBehavior, dataSet, tableName, (IDbCommand)insertCommand, (IDbCommand)updateCommand, (IDbCommand)deleteCommand, updateBatchSize));
}
}
}
public int UpdateDataSet(
DataSet dataSet,
string tableName,
DbCommand insertCommand,
DbCommand updateCommand,
DbCommand deleteCommand,
DbTransaction transaction,
int?updateBatchSize)
{
if (insertCommand != null)
{
Database.PrepareCommand(insertCommand, transaction);
}
if (updateCommand != null)
{
Database.PrepareCommand(updateCommand, transaction);
}
if (deleteCommand != null)
{
Database.PrepareCommand(deleteCommand, transaction);
}
return(this.DoUpdateDataSet(UpdateBehavior.Transactional, dataSet, tableName, (IDbCommand)insertCommand, (IDbCommand)updateCommand, (IDbCommand)deleteCommand, updateBatchSize));
}
public virtual int ExecuteNonQuery(DbCommand command, DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(this.DoExecuteNonQuery(command));
}
public virtual object ExecuteScalar(DbCommand command, DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(this.DoExecuteScalar((IDbCommand)command));
}
public virtual async Task <object> ExecuteScalarAsync(DbCommand command, DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(await this.DoExecuteScalarAsync(command));
}
public virtual async Task <int> ExecuteNonQueryAsync(DbCommand command, DbTransaction transaction)
{
Database.PrepareCommand(command, transaction);
return(await this.DoExecuteNonQueryAsync(command));
}
