/// <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(); } }