#29 model out the asynchrounous interfaces. set namespace friendly names so they will not break once the runtime starts supporting.

kccarter76 · kccarter76 · commit 2d9395461c39 · 2020-07-06T15:10:36.000-06:00
diff --git a/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderQueryProvider.cs b/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderQueryProvider.cs
@@ -34,6 +34,16 @@ public IQueryable<TEntity> CreateQuery<TEntity>(Expression expression)
             return new SubSonicCollection<TEntity>(this, BuildQuery(expression));
         }
 
+        private TResult Scalar<TResult>(IDataRecord reader)
+        {
+            if (reader.FieldCount > 1)
+            {
+                throw new InvalidOperationException();
+            }
+
+            return (TResult)Convert.ChangeType(reader[0], typeof(TResult), CultureInfo.CurrentCulture);
+        }
+
         public TResult Execute<TResult>(Expression expression)
         {
             if (expression is null)
@@ -161,21 +171,31 @@ public TResult Execute<TResult>(Expression expression)
             throw new NotSupportedException(expression.ToString());
         }
 
-        private TResult Scalar<TResult>(IDataRecord reader)
+        public async Task<TResult> ExecuteAsync<TResult>(Expression expression)
         {
-            if (reader.FieldCount > 1)
+            if (expression is null)
             {
-                throw new InvalidOperationException();
+                throw Error.ArgumentNull(nameof(expression));
             }
 
-            return (TResult)Convert.ChangeType(reader[0], typeof(TResult), CultureInfo.CurrentCulture);
+            throw Error.NotImplemented();
+        }
+
+        public async Task<object> ExecuteAsync(Expression expression)
+        {
+            if (expression is null)
+            {
+                throw Error.ArgumentNull(nameof(expression));
+            }
+
+            throw Error.NotImplemented();
         }
 
         public object Execute(Expression expression)
         {
             if (expression is null)
             {
-                throw new ArgumentNullException(nameof(expression));
+                throw Error.ArgumentNull(nameof(expression));
             }
 
             if (expression is DbExpression query)
diff --git a/SubSonic/Infrastructure/Builders/DbSqlTableTypeProvider.cs b/SubSonic/Infrastructure/Builders/DbSqlTableTypeProvider.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace SubSonic.Infrastructure.Builders
 {
@@ -130,14 +131,44 @@ public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
             }
         }
 
+        public async Task<TResult> ExecuteAsync<TResult>(Expression expression)
+        {
+            if (expression is null)
+            {
+                throw Error.ArgumentNull(nameof(expression));
+            }
+
+            throw Error.NotImplemented();
+        }
+
+        public async Task<object> ExecuteAsync(Expression expression)
+        {
+            if (expression is null)
+            {
+                throw Error.ArgumentNull(nameof(expression));
+            }
+
+            throw Error.NotImplemented();
+        }
+
         public object Execute(Expression expression)
         {
-            throw new NotImplementedException();
+            if (expression is null)
+            {
+                throw Error.ArgumentNull(nameof(expression));
+            }
+
+            throw Error.NotImplemented();
         }
 
         public TResult Execute<TResult>(Expression expression)
         {
-            throw new NotImplementedException();
+            if (expression is null)
+            {
+                throw Error.ArgumentNull(nameof(expression));
+            }
+
+            throw Error.NotImplemented();
         }
 
         public IDbPagedQuery ToPagedQuery(Expression expression, int size = 20)
diff --git a/SubSonic/Infrastructure/Database/SubSonicQueryable.cs b/SubSonic/Infrastructure/Database/SubSonicQueryable.cs
@@ -10,6 +10,7 @@ namespace SubSonic.Infrastructure
     using Linq.Expressions;
     using Logging;
     using Schema;
+    using SubSonic.Interfaces;
 
     public sealed class SubSonicCollection<TElement>
         : SubSonicCollection
@@ -33,6 +34,19 @@ public SubSonicCollection(IQueryProvider provider, Expression expression, IEnume
 
         }
 
+        IAsyncSubSonicQueryProvider IAsyncSubSonicQueryable<TElement>.AsyncProvider
+        {
+            get
+            {
+                if (Provider is IAsyncSubSonicQueryProvider provider)
+                {
+                    return provider;
+                }
+
+                return null;
+            }
+        }
+
         #region ICollection<> Implementation
         public void Clear()
         {
@@ -124,6 +138,11 @@ IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()
             }
         }
         #endregion
+
+        IAsyncEnumerator<TElement> IAsyncEnumerable<TElement>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken)
+        {
+            throw Error.NotImplemented();
+        }
     }
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1010:Collections should implement generic interface", Justification = "Generic Class that inherits from this one addresses the generic interface")]
diff --git a/SubSonic/Infrastructure/Database/SubSonicTableTypeQueryable.cs b/SubSonic/Infrastructure/Database/SubSonicTableTypeQueryable.cs
@@ -6,6 +6,7 @@
 
 namespace SubSonic.Infrastructure
 {
+    using Interfaces;
     using Builders;
     using Linq.Expressions;
     using Logging;
@@ -33,6 +34,19 @@ public SubSonicTableTypeCollection(string name, IQueryProvider provider, Express
 
         }
 
+        public IAsyncSubSonicQueryProvider AsyncProvider
+        {
+            get
+            {
+                if (Provider is IAsyncSubSonicQueryProvider provider)
+                {
+                    return provider;
+                }
+
+                return null;
+            }
+        }
+
         #region ICollection<> Implementation
         public void Clear()
         {
@@ -119,6 +133,11 @@ IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()
             }
         }
         #endregion        
+
+        IAsyncEnumerator<TElement> IAsyncEnumerable<TElement>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken)
+        {
+            throw Error.NotImplemented();
+        }
     }
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1010:Collections should implement generic interface", Justification = "Generic Class that inherits from this one addresses the generic interface")]
diff --git a/SubSonic/Infrastructure/DbSetCollection.cs b/SubSonic/Infrastructure/DbSetCollection.cs
@@ -7,6 +7,7 @@
 
 namespace SubSonic.Infrastructure
 {
+    using Interfaces;
     using Data.Caching;
     using Data.DynamicProxies;
     using Linq;
@@ -49,6 +50,19 @@ private void OnDbSetCollectionChanged(object sender, NotifyCollectionChangedEven
 
         public IQueryProvider Provider => provider;
 
+        public IAsyncSubSonicQueryProvider AsyncProvider
+        {
+            get
+            {
+                if (this.provider is IAsyncSubSonicQueryProvider @provider)
+                {
+                    return @provider;
+                }
+
+                return null;
+            }
+        }
+
         #region ICollection<TEntity> Implementation
         void ISubSonicDbSetCollection.Add(object entity)
         {
@@ -152,6 +166,11 @@ IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
             return dataset.Select(x => DynamicProxy.MapInstanceOf(DbContext, x)).GetEnumerator();
         }
 
+        IAsyncEnumerator<TEntity> IAsyncEnumerable<TEntity>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken)
+        {
+            throw Error.NotImplemented();
+        }
+
         public IQueryable Load()
         {
             Provider.Execute(Expression);
diff --git a/SubSonic/Interfaces/Builders/IDbSqlQueryBuilder.cs b/SubSonic/Interfaces/Builders/IDbSqlQueryBuilder.cs
@@ -1,4 +1,5 @@
 ﻿using SubSonic.Infrastructure.Schema;
+using SubSonic.Interfaces;
 using SubSonic.Linq.Expressions;
 using System;
 using System.Collections.Generic;
@@ -9,7 +10,7 @@
 namespace SubSonic.Infrastructure
 {
     public interface ISubSonicQueryProvider
-        : IQueryProvider
+        : IQueryProvider, IAsyncSubSonicQueryProvider
     {
         DbTableExpression DbTable { get; }
 
diff --git a/SubSonic/Interfaces/IAsyncSubSonicQueryProvider.cs b/SubSonic/Interfaces/IAsyncSubSonicQueryProvider.cs
@@ -0,0 +1,24 @@
+﻿using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace SubSonic.Interfaces
+{
+    public interface IAsyncSubSonicQueryProvider
+        : IQueryProvider
+    {
+        /// <summary>
+        /// Executes the expression asynchronously 
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        Task<object> ExecuteAsync(Expression expression);
+        /// <summary>
+        /// Executes the expression asynchronously 
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="Expression"></param>
+        /// <returns></returns>
+        Task<TResult> ExecuteAsync<TResult>(Expression Expression);
+    }
+}
diff --git a/SubSonic/Interfaces/IAsyncSubSonicQueryable.cs b/SubSonic/Interfaces/IAsyncSubSonicQueryable.cs
@@ -0,0 +1,18 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+
+namespace SubSonic.Interfaces
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    public interface IAsyncSubSonicQueryable<out TEntity>
+        : IQueryable, IEnumerable<TEntity>, IAsyncEnumerable<TEntity>
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        IAsyncSubSonicQueryProvider AsyncProvider { get; }
+    }
+}
diff --git a/SubSonic/Interfaces/ISubSonicQueryable.cs b/SubSonic/Interfaces/ISubSonicQueryable.cs
@@ -1,4 +1,5 @@
-﻿using System;
+﻿using SubSonic.Interfaces;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -16,7 +17,7 @@ public interface ISubSonicDbSetCollection<TEntity>
     }
     
     public interface ISubSonicCollection<TEntity>
-        : ISubSonicCollection, IOrderedQueryable<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IQueryable, IEnumerable, ICollection<TEntity>
+        : ISubSonicCollection, IOrderedQueryable<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IAsyncSubSonicQueryable<TEntity>, IQueryable, IEnumerable, ICollection<TEntity>
     {
         void AddRange(IEnumerable<TEntity> entities);
     }

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,16 @@ public IQueryable<TEntity> CreateQuery<TEntity>(Expression expression)`
`34`	`34`	`return new SubSonicCollection<TEntity>(this, BuildQuery(expression));`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ private TResult Scalar<TResult>(IDataRecord reader)`
	`38`	`+ {`
	`39`	`+ if (reader.FieldCount > 1)`
	`40`	`+ {`
	`41`	`+ throw new InvalidOperationException();`
	`42`	`+ }`
	`43`	`+`
	`44`	`+ return (TResult)Convert.ChangeType(reader[0], typeof(TResult), CultureInfo.CurrentCulture);`
	`45`	`+ }`
	`46`	`+`
`37`	`47`	`public TResult Execute<TResult>(Expression expression)`
`38`	`48`	`{`
`39`	`49`	`if (expression is null)`
`@@ -161,21 +171,31 @@ public TResult Execute<TResult>(Expression expression)`
`161`	`171`	`throw new NotSupportedException(expression.ToString());`
`162`	`172`	`}`
`163`	`173`
`164`		`- private TResult Scalar<TResult>(IDataRecord reader)`
	`174`	`+ public async Task<TResult> ExecuteAsync<TResult>(Expression expression)`
`165`	`175`	`{`
`166`		`- if (reader.FieldCount > 1)`
	`176`	`+ if (expression is null)`
`167`	`177`	`{`
`168`		`- throw new InvalidOperationException();`
	`178`	`+ throw Error.ArgumentNull(nameof(expression));`
`169`	`179`	`}`
`170`	`180`
`171`		`- return (TResult)Convert.ChangeType(reader[0], typeof(TResult), CultureInfo.CurrentCulture);`
	`181`	`+ throw Error.NotImplemented();`
	`182`	`+ }`
	`183`	`+`
	`184`	`+ public async Task<object> ExecuteAsync(Expression expression)`
	`185`	`+ {`
	`186`	`+ if (expression is null)`
	`187`	`+ {`
	`188`	`+ throw Error.ArgumentNull(nameof(expression));`
	`189`	`+ }`
	`190`	`+`
	`191`	`+ throw Error.NotImplemented();`
`172`	`192`	`}`
`173`	`193`
`174`	`194`	`public object Execute(Expression expression)`
`175`	`195`	`{`
`176`	`196`	`if (expression is null)`
`177`	`197`	`{`
`178`		`- throw new ArgumentNullException(nameof(expression));`
	`198`	`+ throw Error.ArgumentNull(nameof(expression));`
`179`	`199`	`}`
`180`	`200`
`181`	`201`	`if (expression is DbExpression query)`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace SubSonic.Infrastructure`
`8`	`8`	`{`
	`9`	`+ using Interfaces;`
`9`	`10`	`using Builders;`
`10`	`11`	`using Linq.Expressions;`
`11`	`12`	`using Logging;`
`@@ -33,6 +34,19 @@ public SubSonicTableTypeCollection(string name, IQueryProvider provider, Express`
`33`	`34`
`34`	`35`	`}`
`35`	`36`
	`37`	`+ public IAsyncSubSonicQueryProvider AsyncProvider`
	`38`	`+ {`
	`39`	`+ get`
	`40`	`+ {`
	`41`	`+ if (Provider is IAsyncSubSonicQueryProvider provider)`
	`42`	`+ {`
	`43`	`+ return provider;`
	`44`	`+ }`
	`45`	`+`
	`46`	`+ return null;`
	`47`	`+ }`
	`48`	`+ }`
	`49`	`+`
`36`	`50`	`#region ICollection<> Implementation`
`37`	`51`	`public void Clear()`
`38`	`52`	`{`
`@@ -119,6 +133,11 @@ IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()`
`119`	`133`	`}`
`120`	`134`	`}`
`121`	`135`	`#endregion`
	`136`	`+`
	`137`	`+ IAsyncEnumerator<TElement> IAsyncEnumerable<TElement>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken)`
	`138`	`+ {`
	`139`	`+ throw Error.NotImplemented();`
	`140`	`+ }`
`122`	`141`	`}`
`123`	`142`
`124`	`143`	`[System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1010:Collections should implement generic interface", Justification = "Generic Class that inherits from this one addresses the generic interface")]`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using SubSonic.Infrastructure.Schema;`
	`2`	`+using SubSonic.Interfaces;`
`2`	`3`	`using SubSonic.Linq.Expressions;`
`3`	`4`	`using System;`
`4`	`5`	`using System.Collections.Generic;`
`@@ -9,7 +10,7 @@`
`9`	`10`	`namespace SubSonic.Infrastructure`
`10`	`11`	`{`
`11`	`12`	`public interface ISubSonicQueryProvider`
`12`		`- : IQueryProvider`
	`13`	`+ : IQueryProvider, IAsyncSubSonicQueryProvider`
`13`	`14`	`{`
`14`	`15`	`DbTableExpression DbTable { get; }`
`15`	`16`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System;`
	`1`	`+using SubSonic.Interfaces;`
	`2`	`+using System;`
`2`	`3`	`using System.Collections;`
`3`	`4`	`using System.Collections.Generic;`
`4`	`5`	`using System.ComponentModel;`
`@@ -16,7 +17,7 @@ public interface ISubSonicDbSetCollection<TEntity>`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`public interface ISubSonicCollection<TEntity>`
`19`		`- : ISubSonicCollection, IOrderedQueryable<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IQueryable, IEnumerable, ICollection<TEntity>`
	`20`	`+ : ISubSonicCollection, IOrderedQueryable<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IAsyncSubSonicQueryable<TEntity>, IQueryable, IEnumerable, ICollection<TEntity>`
`20`	`21`	`{`
`21`	`22`	`void AddRange(IEnumerable<TEntity> entities);`
`22`	`23`	`}`