Example #1
0
        public static async Task <int> ExecuteNonQueryAsync(this IDbCommandAsyncExecutor executor, ExecuteNonReaderRequest request)
        {
            var affectedRows = 0;
            await executor.ExecuteAsync(
                request,
                async command => affectedRows = await command.ExecuteNonQueryAsync(request.CancellationToken));

            return(affectedRows);
        }
Example #2
0
        public static async Task <object> ExecuteScalarAsync(this IDbCommandAsyncExecutor executor, ExecuteNonReaderRequest request)
        {
            object scalar = null;
            await executor.ExecuteAsync(
                request,
                async command => scalar = await command.ExecuteScalarAsync(request.CancellationToken));

            return(scalar);
        }
Example #3
0
        public static Task ExecuteAsync(this IDbCommandAsyncExecutor executor, ExecuteNonReaderRequest request, Func <DbCommand, Task> execute)
        {
            var requests = new[]
            {
                new ExecuteCommandAsyncRequest(request.CreateCommandRequest, execute)
            };

            return(executor.ExecuteAsync(requests, request.CancellationToken));
        }
Example #4
0
        public static async Task <List <T> > ExecuteReaderAsync <T>(this IDbCommandAsyncExecutor executor, ExecuteReaderRequest request, Func <IDataRecord, T> read)
        {
            List <T> records = null;
            await executor.ExecuteReaderAsync(
                request,
                async dataReader => records = await dataReader.ReadAsync(read, request.CancellationToken));

            return(records);
        }
Example #5
0
 public static Task ExecuteReaderAsync(this IDbCommandAsyncExecutor executor, ExecuteReaderRequest request, Func <DbDataReader, Task> readResults)
 {
     return(executor.ExecuteAsync(
                new ExecuteNonReaderRequest(request.CreateCommandRequest, request.CancellationToken),
                async command =>
     {
         using (var dataReader = await command.ExecuteReaderAsync(request.CommandBehavior, request.CancellationToken))
             await readResults(dataReader);
     }));
 }
Example #6
0
    public static async Task <ReadOnlySegmentLinkedList <T> > ExecuteReaderAsync <T>(this IDbCommandAsyncExecutor executor, ExecuteReaderRequest request,
                                                                                     int segmentLength, Func <IDataRecord, T> read)
    {
        ReadOnlySegmentLinkedList <T> records = null;
        await executor.ExecuteReaderAsync(
            request,
            async dataReader => records = await dataReader.ReadResultAsync(segmentLength, read, request.CancellationToken));

        return(records);
    }
Example #7
0
 private static Task ExecuteAsync(this IDbCommandAsyncExecutor executor, IEnumerable <ExecuteCommandAsyncRequest> requests, CancellationToken cancellationToken)
 {
     return(executor.ExecuteAsync(async connection =>
     {
         foreach (var request in requests)
         {
             using (var command = connection.CreateCommand(request.CreateCommandRequest))
                 await request.Execute(command);
         }
     }, cancellationToken));
 }
Example #8
0
        public static async Task <ExecuteReaderResponse <T1, T2, T3> > ExecuteReaderAsync <T1, T2, T3>(this IDbCommandAsyncExecutor executor,
                                                                                                       ExecuteReaderRequest request, Func <IDataRecord, T1> read1, Func <IDataRecord, T2> read2, Func <IDataRecord, T3> read3)
        {
            ExecuteReaderResponse <T1, T2, T3> response = null;
            await executor.ExecuteReaderAsync(
                request,
                async dataReader => response = await dataReader.ReadAsync(read1, read2, read3, request.CancellationToken));

            return(response);
        }