/// <summary>
/// Executes the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>The number of <see cref="SqlNonQueryCommand">commands</see> executed.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
if (command == null)
throw new ArgumentNullException("command");
using (var dbConnection = _dbProviderFactory.CreateConnection())
{
dbConnection.ConnectionString = _settings.ConnectionString;
dbConnection.Open();
try
{
using (var dbTransaction = dbConnection.BeginTransaction(_isolationLevel))
{
using (var dbCommand = dbConnection.CreateCommand())
{
dbCommand.Connection = dbConnection;
dbCommand.Transaction = dbTransaction;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
dbCommand.ExecuteNonQuery();
}
dbTransaction.Commit();
}
}
finally
{
dbConnection.Close();
}
}
}
public async Task ExecuteNonQueryAsync(SqlNonQueryCommand command, CancellationToken cancellationToken)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
using (var dbConnection = _connectionFactory())
{
await dbConnection.OpenAsync(cancellationToken);
try
{
using (var dbCommand = dbConnection.CreateCommand())
{
dbCommand.Connection = dbConnection;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
await dbCommand.ExecuteNonQueryAsync(cancellationToken);
}
}
finally
{
dbConnection.Close();
}
}
}
/// <summary>
/// Executes the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>The number of <see cref="SqlNonQueryCommand">commands</see> executed.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
using (var dbConnection = _dbProviderFactory.CreateConnection())
{
dbConnection.ConnectionString = _settings.ConnectionString;
dbConnection.Open();
try
{
using (var dbTransaction = dbConnection.BeginTransaction(_isolationLevel))
{
using (var dbCommand = dbConnection.CreateCommand())
{
dbCommand.Connection = dbConnection;
dbCommand.Transaction = dbTransaction;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
dbCommand.ExecuteNonQuery();
}
dbTransaction.Commit();
}
}
finally
{
dbConnection.Close();
}
}
}
public Task ExecuteNonQueryAsync(SqlNonQueryCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
return(ExecuteNonQueryAsync(command, CancellationToken.None));
}
public void NonQueryProcedureUnlessReturnsExpectedInstance(IEnumerable<SqlNonQueryCommand> actual, SqlNonQueryCommand[] expected)
{
var actualArray = actual.ToArray();
Assert.That(actualArray.Length, Is.EqualTo(expected.Length));
for (var index = 0; index < actualArray.Length; index++)
{
Assert.That(actualArray[index].Text, Is.EqualTo(expected[index].Text));
Assert.That(actualArray[index].Parameters, Is.EquivalentTo(expected[index].Parameters).Using(new SqlParameterEqualityComparer()));
}
}
/// <summary>
/// Executes the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>The number of <see cref="SqlNonQueryCommand">commands</see> executed.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
if (command == null)
throw new ArgumentNullException("command");
using (var dbCommand = _dbConnection.CreateCommand())
{
dbCommand.Connection = _dbConnection;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
dbCommand.ExecuteNonQuery();
}
}
/// <summary>
/// Executes the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>The number of <see cref="SqlNonQueryCommand">commands</see> executed.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
using (var dbCommand = _dbConnection.CreateCommand())
{
dbCommand.Connection = _dbConnection;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
dbCommand.ExecuteNonQuery();
}
}
public WithHandlers()
{
_command = CommandFactory();
_commandArray = new[]
{
CommandFactory(), CommandFactory()
};
_commandEnumeration = Enumerable.Repeat(CommandFactory(), 1);
var commands = new List <SqlNonQueryCommand>();
commands.Add(_command);
commands.AddRange(_commandArray);
commands.AddRange(_commandEnumeration);
_result = commands.ToArray();
When <object>(m => _command);
When <object>(m => _commandArray);
When <object>(m => _commandEnumeration);
}
public void SetUp()
{
_command = CommandFactory();
_commandArray = new[]
{
CommandFactory(), CommandFactory()
};
var commands = new List <SqlNonQueryCommand>();
commands.Add(_command);
commands.AddRange(_commandArray);
_result = commands.ToArray();
_sut = new WithHandlers(new []
{
HandlerFactory(_command),
HandlerFactory(_commandArray),
});
}
private static SqlProjectionHandler HandlerFactory(SqlNonQueryCommand command)
{
return(new SqlProjectionHandler(typeof(object), o => new[] { command }));
}
/// <summary>
/// Executes the specified command asynchronously.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A <see cref="Task" /> that will return when the <see cref="SqlNonQueryCommand">command</see>
/// was executed.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public async Task ExecuteNonQueryAsync(SqlNonQueryCommand command, CancellationToken cancellationToken)
{
if (command == null)
throw new ArgumentNullException("command");
using (var dbCommand = _dbConnection.CreateCommand())
{
dbCommand.Connection = _dbConnection;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
await dbCommand.ExecuteNonQueryAsync(cancellationToken);
}
}
/// <summary>
/// Executes the specified command asynchronously.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>
/// A <see cref="Task" /> that will return when the <see cref="SqlNonQueryCommand">command</see>
/// was executed.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public Task ExecuteNonQueryAsync(SqlNonQueryCommand command)
{
return ExecuteNonQueryAsync(command, CancellationToken.None);
}
public Task ExecuteNonQueryAsync(SqlNonQueryCommand command)
{
return(Task.FromResult <object>(null));
}
private static SqlProjectionHandler HandlerFactory(SqlNonQueryCommand[] commands)
{
return new SqlProjectionHandler(typeof(object), o => commands);
}
/// <summary>
/// Executes the specified command asynchronously.
/// </summary>
/// <param name="command">The command.</param>
/// <returns>
/// A <see cref="Task" /> that will return when the <see cref="SqlNonQueryCommand">command</see>
/// was executed.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public Task ExecuteNonQueryAsync(SqlNonQueryCommand command)
{
return(ExecuteNonQueryAsync(command, CancellationToken.None));
}
private static Func<object, SqlNonQueryCommand> HandlerFactory(SqlNonQueryCommand command)
{
return o => command;
}
/// <summary>
/// Executes the specified command asynchronously.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A <see cref="Task" /> that will return when the <see cref="SqlNonQueryCommand">command</see>
/// was executed.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="command" /> is <c>null</c>.</exception>
public async Task ExecuteNonQueryAsync(SqlNonQueryCommand command, CancellationToken cancellationToken)
{
if (command == null)
throw new ArgumentNullException("command");
using (var dbConnection = _dbProviderFactory.CreateConnection())
{
dbConnection.ConnectionString = _settings.ConnectionString;
await dbConnection.OpenAsync(cancellationToken);
try
{
using (var dbCommand = dbConnection.CreateCommand())
{
dbCommand.Connection = dbConnection;
dbCommand.CommandTimeout = _commandTimeout;
dbCommand.CommandType = command.Type;
dbCommand.CommandText = command.Text;
dbCommand.Parameters.AddRange(command.Parameters);
await dbCommand.ExecuteNonQueryAsync(cancellationToken);
}
}
finally
{
dbConnection.Close();
}
}
}
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
Commands.Add(command);
}
public void NonQueryStatementFormatReturnsExpectedInstance(SqlNonQueryCommand actual, SqlNonQueryCommand expected)
{
Assert.That(actual.Text, Is.EqualTo(expected.Text));
Assert.That(actual.Parameters, Is.EquivalentTo(expected.Parameters).Using(new SQLiteParameterEqualityComparer()));
}
public Task ExecuteNonQueryAsync(SqlNonQueryCommand command, CancellationToken cancellationToken)
{
return(Task.FromResult <object>(null));
}
public void SetUp()
{
_command = CommandFactory();
_commandArray = new[]
{
CommandFactory(), CommandFactory()
};
var commands = new List<SqlNonQueryCommand>();
commands.Add(_command);
commands.AddRange(_commandArray);
_result = commands.ToArray();
_sut = new WithHandlers(new []
{
HandlerFactory(_command),
HandlerFactory(_commandArray),
});
}
public WithHandlers()
{
_command = CommandFactory();
_commandArray = new[]
{
CommandFactory(), CommandFactory()
};
_commandEnumeration = Enumerable.Repeat(CommandFactory(), 1);
var commands = new List<SqlNonQueryCommand>();
commands.Add(_command);
commands.AddRange(_commandArray);
commands.AddRange(_commandEnumeration);
_result = commands.ToArray();
When<object>(m => _command);
When<object>(m => _commandArray);
When<object>(m => _commandEnumeration);
}
private static Func <object, SqlNonQueryCommand> HandlerFactory(SqlNonQueryCommand command)
{
return(o => command);
}
public void NonQueryProcedureReturnsExpectedInstance(SqlNonQueryCommand actual, SqlNonQueryCommand expected)
{
Assert.That(actual.Text, Is.EqualTo(expected.Text));
Assert.That(actual.Parameters, Is.EquivalentTo(expected.Parameters).Using(new SqlParameterEqualityComparer()));
}
public void ExecuteNonQuery(SqlNonQueryCommand command)
{
}
private static SqlProjectionHandler HandlerFactory(SqlNonQueryCommand command)
{
return new SqlProjectionHandler(typeof(object), o => new[] {command});
}