Enhancing ORM QueryBuilder with async

csbernath · csbernath · commit 6a780915c862 · 2018-04-11T20:47:19.000+02:00
diff --git a/Foundation.NetStandard-2.0/Collections/SegmentedCollection.cs b/Foundation.NetStandard-2.0/Collections/SegmentedCollection.cs
@@ -1,14 +1,10 @@
 ﻿using System;
 using System.Collections;
 using System.Collections.Generic;
-using Foundation.Diagnostics.Contracts;
+using Foundation.Assertions;
 
 namespace Foundation.Collections
 {
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class SegmentedCollection<T> : ICollection<T>
     {
         #region Private Fields
@@ -19,14 +15,9 @@ public class SegmentedCollection<T> : ICollection<T>
 
         #endregion
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="segmentLength"></param>
         public SegmentedCollection(int segmentLength)
         {
-            FoundationContract.Requires<ArgumentOutOfRangeException>(segmentLength > 0);
-
+            Assert.IsInRange(segmentLength > 0);
             _segmentLength = segmentLength;
         }
 
diff --git a/Foundation.NetStandard-2.0/Collections/SegmentedListBuilder.cs b/Foundation.NetStandard-2.0/Collections/SegmentedListBuilder.cs
@@ -54,29 +54,19 @@ public void Add(T item)
             _nextSegmentItemIndex++;
         }
 
-        /// <summary>
-        /// 
-        /// </summary>
         public int Count
         {
             get
             {
                 var count = 0;
                 var segmentCount = _segments.Count;
                 if (segmentCount > 0)
-                {
-                    count += (segmentCount - 1)* _segmentItemCapacity;
-                }
+                    count += (segmentCount - 1) * _segmentItemCapacity;
                 count += _nextSegmentItemIndex;
-
                 return count;
             }
         }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <returns></returns>
         public IReadOnlyList<T> ToReadOnlyList()
         {
             var count = Count;
@@ -94,18 +84,18 @@ public ReadOnlySegmentedList(IList<T[]> segments, int count)
                 _count = count;
             }
 
-#region IReadOnlyList<T> Members
+            #region IReadOnlyList<T> Members
 
             T IReadOnlyList<T>.this[int index]
             {
                 get
                 {
                     var segmentLength = _segments[0].Length;
 
-                    var segmentIndex = index/segmentLength;
+                    var segmentIndex = index / segmentLength;
                     var segment = _segments[segmentIndex];
 
-                    var segmentItemIndex = index%segmentLength;
+                    var segmentItemIndex = index % segmentLength;
                     var value = segment[segmentItemIndex];
                     return value;
                 }
@@ -134,10 +124,10 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
 
             IEnumerator IEnumerable.GetEnumerator()
             {
-                return ((IEnumerable<T>)this).GetEnumerator();
+                return ((IEnumerable<T>) this).GetEnumerator();
             }
 
-#endregion
+            #endregion
         }
     }
 }
diff --git a/Foundation.NetStandard-2.0/Data/DbDataReaderExtensions.cs b/Foundation.NetStandard-2.0/Data/DbDataReaderExtensions.cs
@@ -10,13 +10,13 @@ namespace Foundation.Data
 {
     public static class DbDataReaderExtensions
     {
-        private static async Task ReadAsync(this DbDataReader dataReader, Action read, CancellationToken cancellationToken)
+        public static async Task ReadResultAsync(this DbDataReader dataReader, Action readRecord, CancellationToken cancellationToken)
         {
             while (await dataReader.ReadAsync(cancellationToken))
-                read();
+                readRecord();
         }
 
-        public static async Task ReadAsync(this DbDataReader dataReader, IEnumerable<Func<Task>> reads, CancellationToken cancellationToken)
+        public static async Task ReadResultAsync(this DbDataReader dataReader, IEnumerable<Func<Task>> reads, CancellationToken cancellationToken)
         {
             var first = true;
             foreach (var read in reads)
@@ -33,20 +33,28 @@ public static async Task ReadAsync(this DbDataReader dataReader, IEnumerable<Fun
             }
         }
 
-        public static async Task<List<T>> ReadAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> read, CancellationToken cancellationToken)
+        public static async Task<List<T>> ReadResultAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> readRecord, CancellationToken cancellationToken)
         {
             var records = new List<T>();
 
-            await dataReader.ReadAsync(() =>
+            await dataReader.ReadResultAsync(() =>
             {
-                var record = read(dataReader);
+                var record = readRecord(dataReader);
                 records.Add(record);
             }, cancellationToken);
 
             return records;
         }
 
-        public static async Task<ExecuteReaderResponse<T1, T2>> ReadAsync<T1, T2>(
+        public static async Task<List<T>> ReadNextResultAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> readRecord, CancellationToken cancellationToken)
+        {
+            var nextResult = await dataReader.NextResultAsync(cancellationToken);
+            Assert.IsTrue(nextResult);
+            var records = await dataReader.ReadResultAsync(readRecord, cancellationToken);
+            return records;
+        }
+
+        public static async Task<ExecuteReaderResponse<T1, T2>> ReadResultAsync<T1, T2>(
             this DbDataReader dataReader,
             Func<IDataRecord, T1> read1,
             Func<IDataRecord, T2> read2,
@@ -57,16 +65,16 @@ public static async Task<ExecuteReaderResponse<T1, T2>> ReadAsync<T1, T2>(
 
             var readResults = new Func<Task>[]
             {
-                async () => objects1 = await dataReader.ReadAsync(read1, cancellationToken),
-                async () => objects2 = await dataReader.ReadAsync(read2, cancellationToken),
+                async () => objects1 = await dataReader.ReadResultAsync(read1, cancellationToken),
+                async () => objects2 = await dataReader.ReadResultAsync(read2, cancellationToken),
             };
 
-            await dataReader.ReadAsync(readResults, cancellationToken);
+            await dataReader.ReadResultAsync(readResults, cancellationToken);
 
             return ExecuteReaderResponse.Create(objects1, objects2);
         }
 
-        public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadAsync<T1, T2, T3>(
+        public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadResultAsync<T1, T2, T3>(
             this DbDataReader dataReader,
             Func<IDataRecord, T1> read1,
             Func<IDataRecord, T2> read2,
@@ -79,12 +87,12 @@ public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadAsync<T1, T2, T3
 
             var reads = new Func<Task>[]
             {
-                async () => objects1 = (await dataReader.ReadAsync(read1, cancellationToken)),
-                async () => objects2 = (await dataReader.ReadAsync(read2, cancellationToken)),
-                async () => objects3 = (await dataReader.ReadAsync(read3, cancellationToken)),
+                async () => objects1 = (await dataReader.ReadResultAsync(read1, cancellationToken)),
+                async () => objects2 = (await dataReader.ReadResultAsync(read2, cancellationToken)),
+                async () => objects3 = (await dataReader.ReadResultAsync(read3, cancellationToken)),
             };
 
-            await dataReader.ReadAsync(reads, cancellationToken);
+            await dataReader.ReadResultAsync(reads, cancellationToken);
 
             return ExecuteReaderResponse.Create(objects1, objects2, objects3);
         }
diff --git a/Foundation.NetStandard-2.0/Data/IDataReaderExtensions.cs b/Foundation.NetStandard-2.0/Data/IDataReaderExtensions.cs
@@ -92,14 +92,6 @@ public static ExecuteReaderResponse<T1, T2, T3> Read<T1, T2, T3>(this IDataReade
             return ExecuteReaderResponse.Create(result1, result2, result3);
         }
 
-        public static IEnumerable<IDataReader> AsEnumerable(this IDataReader dataReader)
-        {
-            Assert.IsNotNull(dataReader);
-
-            while (dataReader.Read())
-                yield return dataReader;
-        }
-
         public static int Fill(this IDataReader dataReader, DataSet dataSet, CancellationToken cancellationToken)
         {
             Assert.IsNotNull(dataReader);
diff --git a/Foundation.NetStandard-2.0/Data/IDbCommandAsyncExecutorExtensions.cs b/Foundation.NetStandard-2.0/Data/IDbCommandAsyncExecutorExtensions.cs
@@ -14,10 +14,8 @@ private static Task ExecuteAsync(this IDbCommandAsyncExecutor executor, IEnumera
             return executor.ExecuteAsync(async connection =>
             {
                 foreach (var request in requests)
-                {
                     using (var command = connection.CreateCommand(request.CreateCommandRequest))
                         await request.Execute(command);
-                }
             }, cancellationToken);
         }
 
@@ -48,12 +46,23 @@ await executor.ExecuteAsync(
             return scalar;
         }
 
+        public static Task ExecuteReaderAsync(this IDbCommandAsyncExecutor executor, ExecuteReaderRequest request, Func<DbDataReader, Task> read)
+        {
+            return executor.ExecuteAsync(
+                new ExecuteNonReaderRequest(request.CreateCommandRequest, request.CancellationToken),
+                async command =>
+                {
+                    using (var dataReader = await command.ExecuteReaderAsync(request.CommandBehavior, request.CancellationToken))
+                        await read(dataReader);
+                });
+        }
+
         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));
+                async dataReader => records = await dataReader.ReadResultAsync(read, request.CancellationToken));
             return records;
         }
 
@@ -63,7 +72,7 @@ public static async Task<ExecuteReaderResponse<T1, T2>> ExecuteReaderAsync<T1, T
             ExecuteReaderResponse<T1, T2> response = null;
             await executor.ExecuteReaderAsync(
                 request,
-                async dataReader => response = await dataReader.ReadAsync(read1, read2, request.CancellationToken));
+                async dataReader => response = await dataReader.ReadResultAsync(read1, read2, request.CancellationToken));
             return response;
         }
 
@@ -73,19 +82,8 @@ public static async Task<ExecuteReaderResponse<T1, T2, T3>> ExecuteReaderAsync<T
             ExecuteReaderResponse<T1, T2, T3> response = null;
             await executor.ExecuteReaderAsync(
                 request,
-                async dataReader => response = await dataReader.ReadAsync(read1, read2, read3, request.CancellationToken));
+                async dataReader => response = await dataReader.ReadResultAsync(read1, read2, read3, request.CancellationToken));
             return response;
         }
-
-        private static Task ExecuteReaderAsync(this IDbCommandAsyncExecutor executor, ExecuteReaderRequest request, Func<DbDataReader, Task> read)
-        {
-            return executor.ExecuteAsync(
-                new ExecuteNonReaderRequest(request.CreateCommandRequest, request.CancellationToken),
-                async command =>
-                {
-                    using (var dataReader = await command.ExecuteReaderAsync(request.CommandBehavior, request.CancellationToken))
-                        await read(dataReader);
-                });
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -54,29 +54,19 @@ public void Add(T item)`
`54`	`54`	`_nextSegmentItemIndex++;`
`55`	`55`	`}`
`56`	`56`
`57`		`- /// <summary>`
`58`		`- ///`
`59`		`- /// </summary>`
`60`	`57`	`public int Count`
`61`	`58`	`{`
`62`	`59`	`get`
`63`	`60`	`{`
`64`	`61`	`var count = 0;`
`65`	`62`	`var segmentCount = _segments.Count;`
`66`	`63`	`if (segmentCount > 0)`
`67`		`- {`
`68`		`- count += (segmentCount - 1)* _segmentItemCapacity;`
`69`		`- }`
	`64`	`+ count += (segmentCount - 1) * _segmentItemCapacity;`
`70`	`65`	`count += _nextSegmentItemIndex;`
`71`		`-`
`72`	`66`	`return count;`
`73`	`67`	`}`
`74`	`68`	`}`
`75`	`69`
`76`		`- /// <summary>`
`77`		`- ///`
`78`		`- /// </summary>`
`79`		`- /// <returns></returns>`
`80`	`70`	`public IReadOnlyList<T> ToReadOnlyList()`
`81`	`71`	`{`
`82`	`72`	`var count = Count;`
`@@ -94,18 +84,18 @@ public ReadOnlySegmentedList(IList<T[]> segments, int count)`
`94`	`84`	`_count = count;`
`95`	`85`	`}`
`96`	`86`
`97`		`-#region IReadOnlyList<T> Members`
	`87`	`+ #region IReadOnlyList<T> Members`
`98`	`88`
`99`	`89`	`T IReadOnlyList<T>.this[int index]`
`100`	`90`	`{`
`101`	`91`	`get`
`102`	`92`	`{`
`103`	`93`	`var segmentLength = _segments[0].Length;`
`104`	`94`
`105`		`- var segmentIndex = index/segmentLength;`
	`95`	`+ var segmentIndex = index / segmentLength;`
`106`	`96`	`var segment = _segments[segmentIndex];`
`107`	`97`
`108`		`- var segmentItemIndex = index%segmentLength;`
	`98`	`+ var segmentItemIndex = index % segmentLength;`
`109`	`99`	`var value = segment[segmentItemIndex];`
`110`	`100`	`return value;`
`111`	`101`	`}`
`@@ -134,10 +124,10 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`134`	`124`
`135`	`125`	`IEnumerator IEnumerable.GetEnumerator()`
`136`	`126`	`{`
`137`		`- return ((IEnumerable<T>)this).GetEnumerator();`
	`127`	`+ return ((IEnumerable<T>) this).GetEnumerator();`
`138`	`128`	`}`
`139`	`129`
`140`		`-#endregion`
	`130`	`+ #endregion`
`141`	`131`	`}`
`142`	`132`	`}`
`143`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,13 +10,13 @@ namespace Foundation.Data`
`10`	`10`	`{`
`11`	`11`	`public static class DbDataReaderExtensions`
`12`	`12`	`{`
`13`		`- private static async Task ReadAsync(this DbDataReader dataReader, Action read, CancellationToken cancellationToken)`
	`13`	`+ public static async Task ReadResultAsync(this DbDataReader dataReader, Action readRecord, CancellationToken cancellationToken)`
`14`	`14`	`{`
`15`	`15`	`while (await dataReader.ReadAsync(cancellationToken))`
`16`		`- read();`
	`16`	`+ readRecord();`
`17`	`17`	`}`
`18`	`18`
`19`		`- public static async Task ReadAsync(this DbDataReader dataReader, IEnumerable<Func<Task>> reads, CancellationToken cancellationToken)`
	`19`	`+ public static async Task ReadResultAsync(this DbDataReader dataReader, IEnumerable<Func<Task>> reads, CancellationToken cancellationToken)`
`20`	`20`	`{`
`21`	`21`	`var first = true;`
`22`	`22`	`foreach (var read in reads)`
`@@ -33,20 +33,28 @@ public static async Task ReadAsync(this DbDataReader dataReader, IEnumerable<Fun`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`- public static async Task<List<T>> ReadAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> read, CancellationToken cancellationToken)`
	`36`	`+ public static async Task<List<T>> ReadResultAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> readRecord, CancellationToken cancellationToken)`
`37`	`37`	`{`
`38`	`38`	`var records = new List<T>();`
`39`	`39`
`40`		`- await dataReader.ReadAsync(() =>`
	`40`	`+ await dataReader.ReadResultAsync(() =>`
`41`	`41`	`{`
`42`		`- var record = read(dataReader);`
	`42`	`+ var record = readRecord(dataReader);`
`43`	`43`	`records.Add(record);`
`44`	`44`	`}, cancellationToken);`
`45`	`45`
`46`	`46`	`return records;`
`47`	`47`	`}`
`48`	`48`
`49`		`- public static async Task<ExecuteReaderResponse<T1, T2>> ReadAsync<T1, T2>(`
	`49`	`+ public static async Task<List<T>> ReadNextResultAsync<T>(this DbDataReader dataReader, Func<IDataRecord, T> readRecord, CancellationToken cancellationToken)`
	`50`	`+ {`
	`51`	`+ var nextResult = await dataReader.NextResultAsync(cancellationToken);`
	`52`	`+ Assert.IsTrue(nextResult);`
	`53`	`+ var records = await dataReader.ReadResultAsync(readRecord, cancellationToken);`
	`54`	`+ return records;`
	`55`	`+ }`
	`56`	`+`
	`57`	`+ public static async Task<ExecuteReaderResponse<T1, T2>> ReadResultAsync<T1, T2>(`
`50`	`58`	`this DbDataReader dataReader,`
`51`	`59`	`Func<IDataRecord, T1> read1,`
`52`	`60`	`Func<IDataRecord, T2> read2,`
`@@ -57,16 +65,16 @@ public static async Task<ExecuteReaderResponse<T1, T2>> ReadAsync<T1, T2>(`
`57`	`65`
`58`	`66`	`var readResults = new Func<Task>[]`
`59`	`67`	`{`
`60`		`- async () => objects1 = await dataReader.ReadAsync(read1, cancellationToken),`
`61`		`- async () => objects2 = await dataReader.ReadAsync(read2, cancellationToken),`
	`68`	`+ async () => objects1 = await dataReader.ReadResultAsync(read1, cancellationToken),`
	`69`	`+ async () => objects2 = await dataReader.ReadResultAsync(read2, cancellationToken),`
`62`	`70`	`};`
`63`	`71`
`64`		`- await dataReader.ReadAsync(readResults, cancellationToken);`
	`72`	`+ await dataReader.ReadResultAsync(readResults, cancellationToken);`
`65`	`73`
`66`	`74`	`return ExecuteReaderResponse.Create(objects1, objects2);`
`67`	`75`	`}`
`68`	`76`
`69`		`- public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadAsync<T1, T2, T3>(`
	`77`	`+ public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadResultAsync<T1, T2, T3>(`
`70`	`78`	`this DbDataReader dataReader,`
`71`	`79`	`Func<IDataRecord, T1> read1,`
`72`	`80`	`Func<IDataRecord, T2> read2,`
`@@ -79,12 +87,12 @@ public static async Task<ExecuteReaderResponse<T1, T2, T3>> ReadAsync<T1, T2, T3`
`79`	`87`
`80`	`88`	`var reads = new Func<Task>[]`
`81`	`89`	`{`
`82`		`- async () => objects1 = (await dataReader.ReadAsync(read1, cancellationToken)),`
`83`		`- async () => objects2 = (await dataReader.ReadAsync(read2, cancellationToken)),`
`84`		`- async () => objects3 = (await dataReader.ReadAsync(read3, cancellationToken)),`
	`90`	`+ async () => objects1 = (await dataReader.ReadResultAsync(read1, cancellationToken)),`
	`91`	`+ async () => objects2 = (await dataReader.ReadResultAsync(read2, cancellationToken)),`
	`92`	`+ async () => objects3 = (await dataReader.ReadResultAsync(read3, cancellationToken)),`
`85`	`93`	`};`
`86`	`94`
`87`		`- await dataReader.ReadAsync(reads, cancellationToken);`
	`95`	`+ await dataReader.ReadResultAsync(reads, cancellationToken);`
`88`	`96`
`89`	`97`	`return ExecuteReaderResponse.Create(objects1, objects2, objects3);`
`90`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,14 +92,6 @@ public static ExecuteReaderResponse<T1, T2, T3> Read<T1, T2, T3>(this IDataReade`
`92`	`92`	`return ExecuteReaderResponse.Create(result1, result2, result3);`
`93`	`93`	`}`
`94`	`94`
`95`		`- public static IEnumerable<IDataReader> AsEnumerable(this IDataReader dataReader)`
`96`		`- {`
`97`		`- Assert.IsNotNull(dataReader);`
`98`		`-`
`99`		`- while (dataReader.Read())`
`100`		`- yield return dataReader;`
`101`		`- }`
`102`		`-`
`103`	`95`	`public static int Fill(this IDataReader dataReader, DataSet dataSet, CancellationToken cancellationToken)`
`104`	`96`	`{`
`105`	`97`	`Assert.IsNotNull(dataReader);`