/// <summary>
/// Execute the operation asynchronously.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">User defined state, usually used for logging.</param>
/// <returns>Task<System.Nullable<System.Int32>>.</returns>
public Task <int?> ExecuteAsync(CancellationToken cancellationToken, object?state = null)
{
var token = Prepare();
OperationImplementationAsync <TConnection, TTransaction> implementation = m_OperationBuilder.ImplementationAsync;
return(token.ExecuteAsync(implementation, cancellationToken, state));
}
/// <summary>
/// Execute the operation asynchronously.
/// </summary>
/// <param name="executionToken">The execution token.</param>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
protected override async Task <int?> ExecuteAsync(OperationExecutionToken <OleDbConnection, OleDbTransaction> executionToken, OperationImplementationAsync <OleDbConnection, OleDbTransaction> implementation, CancellationToken cancellationToken, object state)
{
if (executionToken == null)
{
throw new ArgumentNullException("executionToken", "executionToken is null.");
}
if (implementation == null)
{
throw new ArgumentNullException("implementation", "implementation is null.");
}
var startTime = DateTimeOffset.Now;
OnExecutionStarted(executionToken, startTime, state);
try
{
var rows = await implementation(m_Connection, m_Transaction, cancellationToken).ConfigureAwait(false);
OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state);
return(rows);
}
catch (Exception ex)
{
if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException
{
var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken);
OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state);
throw ex2;
}
else
{
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state);
throw;
}
}
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="executionToken">The execution token.</param>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
protected override async Task <int?> ExecuteAsync(OperationExecutionToken <SQLiteConnection, SQLiteTransaction> executionToken, OperationImplementationAsync <SQLiteConnection, SQLiteTransaction> implementation, CancellationToken cancellationToken, object?state)
{
if (executionToken == null)
{
throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null.");
}
if (implementation == null)
{
throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null.");
}
var mode = DisableLocks ? LockType.None : (executionToken as SQLiteOperationExecutionToken)?.LockType ?? LockType.Write;
var startTime = DateTimeOffset.Now;
OnExecutionStarted(executionToken, startTime, state);
IDisposable?lockToken = null;
try
{
switch (mode)
{
case LockType.Read: lockToken = await SyncLock.ReaderLockAsync().ConfigureAwait(false); break;
case LockType.Write: lockToken = await SyncLock.WriterLockAsync().ConfigureAwait(false); break;
}
var rows = await implementation(m_Connection, m_Transaction, cancellationToken).ConfigureAwait(false);
OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state);
return(rows);
}
catch (Exception ex)
{
if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException
{
var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken);
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state);
throw ex2;
}
else
{
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state);
throw;
}
}
finally
{
if (lockToken != null)
{
lockToken.Dispose();
}
}
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="executionToken">The execution token.</param>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
/// <exception cref="ArgumentNullException">
/// executionToken;executionToken is null.
/// or
/// implementation;implementation is null.
/// </exception>
protected override async Task <int?> ExecuteAsync(OperationExecutionToken <MySqlConnection, MySqlTransaction> executionToken, OperationImplementationAsync <MySqlConnection, MySqlTransaction> implementation, CancellationToken cancellationToken, object?state)
{
if (executionToken == null)
{
throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null.");
}
if (implementation == null)
{
throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null.");
}
var startTime = DateTimeOffset.Now;
OnExecutionStarted(executionToken, startTime, state);
try
{
using (var con = CreateConnection())
{
var rows = await implementation(con, null, cancellationToken).ConfigureAwait(false);
OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state);
return(rows);
}
}
catch (Exception ex)
{
if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException
{
var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken);
OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state);
throw ex2;
}
else
{
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state);
throw;
}
}
}
Task <int?> IOperationDataSource <TConnection, TTransaction> .ExecuteAsync(OperationExecutionToken <TConnection, TTransaction> executionToken, OperationImplementationAsync <TConnection, TTransaction> implementation, CancellationToken cancellationToken, object state)
{
return(ExecuteAsync(executionToken, implementation, cancellationToken, state));
}
/// <summary> /// Execute the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">The state.</param> /// <returns>Task.</returns> protected internal abstract Task <int?> ExecuteAsync(OperationExecutionToken <TConnection, TTransaction> executionToken, OperationImplementationAsync <TConnection, TTransaction> implementation, CancellationToken cancellationToken, object state);
/// <summary>
/// Execute the operation asynchronously.
/// </summary>
/// <param name="executionToken">The execution token.</param>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
protected override async Task<int?> ExecuteAsync(OperationExecutionToken<OleDbConnection, OleDbTransaction> executionToken, OperationImplementationAsync<OleDbConnection, OleDbTransaction> implementation, CancellationToken cancellationToken, object state)
{
if (executionToken == null)
throw new ArgumentNullException("executionToken", "executionToken is null.");
if (implementation == null)
throw new ArgumentNullException("implementation", "implementation is null.");
var startTime = DateTimeOffset.Now;
OnExecutionStarted(executionToken, startTime, state);
try
{
using (var con = CreateConnection())
{
var rows = await implementation(con, null, cancellationToken).ConfigureAwait(false);
OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state);
return rows;
}
}
catch (Exception ex)
{
if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException
{
var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken);
OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state);
throw ex2;
}
else
{
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state);
throw;
}
}
}
/// <summary>
/// Executes the specified implementation asynchronously.
/// </summary>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
public Task <int?> ExecuteAsync(OperationImplementationAsync <TConnection, TTransaction> implementation, CancellationToken cancellationToken, object state)
{
return(m_DataSource.ExecuteAsync(this, implementation, cancellationToken, state));
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="executionToken">The execution token.</param>
/// <param name="implementation">The implementation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="state">The state.</param>
/// <returns>Task.</returns>
protected override async Task<int?> ExecuteAsync(OperationExecutionToken<SQLiteConnection, SQLiteTransaction> executionToken, OperationImplementationAsync<SQLiteConnection, SQLiteTransaction> implementation, CancellationToken cancellationToken, object state)
{
if (executionToken == null)
throw new ArgumentNullException("executionToken", "executionToken is null.");
if (implementation == null)
throw new ArgumentNullException("implementation", "implementation is null.");
var mode = DisableLocks ? LockType.None : (executionToken as SQLiteOperationExecutionToken)?.LockType ?? LockType.Write;
var startTime = DateTimeOffset.Now;
OnExecutionStarted(executionToken, startTime, state);
IDisposable lockToken = null;
try
{
switch (mode)
{
case LockType.Read: lockToken = await SyncLock.ReaderLockAsync().ConfigureAwait(false); break;
case LockType.Write: lockToken = await SyncLock.WriterLockAsync().ConfigureAwait(false); break;
}
using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false))
{
var rows = await implementation(con, null, cancellationToken).ConfigureAwait(false);
OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state);
return rows;
}
}
catch (Exception ex)
{
if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException
{
var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken);
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state);
throw ex2;
}
else
{
OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state);
throw;
}
}
finally
{
if (lockToken != null)
lockToken.Dispose();
}
}
