rework handling enumerating result

Ihar Yakimush · Ihar Yakimush · commit 2febee89f898 · 2018-08-07T09:51:18.000+03:00
diff --git a/SolrNet.Linq/SolrLinqExtensions.cs b/SolrNet.Linq/SolrLinqExtensions.cs
@@ -18,9 +18,9 @@ public static async Task<TSource> FirstAsync<TSource>(this IQueryable<TSource> q
                     GetMethod<TSource>(nameof(Queryable.First), 1),
                     query.Expression);
 
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(mce);
+                TSource result = await provider.ExecuteAsync<TSource>(mce);
 
-                return result.First();
+                return result;
             }
 
             return query.First();
@@ -30,11 +30,11 @@ public static async Task<TSource> FirstAsync<TSource>(this IQueryable<TSource> q
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.First), 2), query.Expression, predicate));
 
-                return result.First();
+                return result;
             }
 
             return query.First(predicate);
@@ -44,11 +44,11 @@ public static async Task<TSource> FirstOrDefaultAsync<TSource>(this IQueryable<T
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.FirstOrDefault), 1), query.Expression));
 
-                return result.FirstOrDefault();
+                return result;
             }
 
             return query.FirstOrDefault();
@@ -58,11 +58,11 @@ public static async Task<TSource> FirstOrDefaultAsync<TSource>(this IQueryable<T
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.FirstOrDefault), 2), query.Expression, predicate));
 
-                return result.FirstOrDefault();
+                return result;
             }
 
             return query.FirstOrDefault(predicate);
@@ -72,11 +72,11 @@ public static async Task<TSource> SingleAsync<TSource>(this IQueryable<TSource>
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.Single), 1), query.Expression));
 
-                return result.Single();
+                return result;
             }
 
             return query.Single();
@@ -86,11 +86,11 @@ public static async Task<TSource> SingleAsync<TSource>(this IQueryable<TSource>
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.Single), 2), query.Expression, predicate));
 
-                return result.Single();
+                return result;
             }
 
             return query.Single(predicate);
@@ -100,11 +100,11 @@ public static async Task<TSource> SingleOrDefaultAsync<TSource>(this IQueryable<
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.SingleOrDefault), 1), query.Expression));
 
-                return result.SingleOrDefault();
+                return result;
             }
 
             return query.SingleOrDefault();
@@ -114,11 +114,11 @@ public static async Task<TSource> SingleOrDefaultAsync<TSource>(this IQueryable<
         {
             if (query.Provider is SolrQueryProvider<TSource> provider)
             {
-                SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(
+                TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(
                     null,
                     GetMethod<TSource>(nameof(Queryable.SingleOrDefault), 2), query.Expression, predicate));
 
-                return result.SingleOrDefault();
+                return result;
             }
 
             return query.SingleOrDefault(predicate);
diff --git a/SolrNet.Linq/SolrNet.Linq.csproj b/SolrNet.Linq/SolrNet.Linq.csproj
@@ -12,7 +12,7 @@
     <PackageTags>solr solrnet linq</PackageTags>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
-    <Version>1.2.0</Version>
+    <Version>1.2.1</Version>
     <PackageReleaseNotes>support First(), FirstOrDefault(). Single(), SingleOrDefault() methods and its async versions</PackageReleaseNotes>
   </PropertyGroup>
 
diff --git a/SolrNet.Linq/SolrOperationsExtensions.cs b/SolrNet.Linq/SolrOperationsExtensions.cs
@@ -17,14 +17,14 @@ public static SolrQuery<T> AsQueryable<T>(this ISolrBasicReadOnlyOperations<T> o
 
         public static SolrQueryResults<T> ToSolrQueryResults<T>(this IQueryable<T> queryable)
         {
-            return queryable.Provider.Execute(queryable.Expression) as SolrQueryResults<T>;
+            return (SolrQueryResults<T>)queryable.Provider.Execute(queryable.Expression);
         }
 
         public static Task<SolrQueryResults<T>> ToSolrQueryResultsAsync<T>(this IQueryable<T> queryable)
         {
             if (queryable.Provider is SolrQueryProvider<T> solrProvider)
             {
-                return solrProvider.ExecuteAsync(queryable.Expression);
+                return solrProvider.ExecuteAsync<SolrQueryResults<T>>(queryable.Expression);
             }
 
             return Task.FromResult(ToSolrQueryResults(queryable));
diff --git a/SolrNet.Linq/SolrQueryProvider.cs b/SolrNet.Linq/SolrQueryProvider.cs
@@ -51,12 +51,16 @@ public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
 
         public object Execute(Expression expression)
         {
-            SolrQueryTranslator translator = new SolrQueryTranslator(this.Options, this.MemberContext);
-            Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = translator.Translate(this, expression);
-            this.Options.SetupQueryOptions?.Invoke(result.Item2);
+            Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = Translate(expression);
+
             SolrQueryResults<TEntity> solrQueryResults =
                 Operations.Query(this.Options.MainQuery ?? result.Item1, result.Item2);
 
+            return HandleResults(result, solrQueryResults);
+        }
+
+        private static object HandleResults(Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result, SolrQueryResults<TEntity> solrQueryResults)
+        {
             switch (result.Item3)
             {
                 case EnumeratedResult.First: return solrQueryResults.First();
@@ -68,6 +72,14 @@ public object Execute(Expression expression)
             }
         }
 
+        private Tuple<ISolrQuery, QueryOptions, EnumeratedResult> Translate(Expression expression)
+        {
+            SolrQueryTranslator translator = new SolrQueryTranslator(this.Options, this.MemberContext);
+            Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = translator.Translate(this, expression);
+            this.Options.SetupQueryOptions?.Invoke(result.Item2);
+            return result;
+        }
+
         public MemberContext MemberContext
         {
             get
@@ -79,25 +91,37 @@ public MemberContext MemberContext
             }
         }
 
-        public Task<SolrQueryResults<TEntity>> ExecuteAsync(Expression expression)
+        public async Task<object> ExecuteAsync(Expression expression)
         {
-            SolrQueryTranslator
-                translator = new SolrQueryTranslator(this.Options, this.MemberContext);
-            var result = translator.Translate(this, expression);
-            this.Options.SetupQueryOptions?.Invoke(result.Item2);
-            
-            return Operations.QueryAsync(this.Options.MainQuery ?? result.Item1, result.Item2);
+            Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = Translate(expression);
+
+            SolrQueryResults<TEntity> solrQueryResults =
+                await Operations.QueryAsync(this.Options.MainQuery ?? result.Item1, result.Item2);
+
+            return HandleResults(result, solrQueryResults);            
         }
 
         public TResult Execute<TResult>(Expression expression)
         {
             object providerResult = this.Execute(expression);
 
+            return CastResult<TResult>(providerResult);
+        }
+
+        public async Task<TResult> ExecuteAsync<TResult>(Expression expression)
+        {
+            object providerResult = await this.ExecuteAsync(expression);
+
+            return CastResult<TResult>(providerResult);
+        }
+
+        private static TResult CastResult<TResult>(object providerResult)
+        {
             TResult result = default(TResult);
 
             try
             {
-                result = (TResult)providerResult;
+                result = (TResult) providerResult;
             }
             catch (InvalidCastException exception)
             {
@@ -110,6 +134,6 @@ public TResult Execute<TResult>(Expression expression)
             }
 
             return result;
-        }        
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,9 @@ public static async Task<TSource> FirstAsync<TSource>(this IQueryable<TSource> q`
`18`	`18`	`GetMethod<TSource>(nameof(Queryable.First), 1),`
`19`	`19`	`query.Expression);`
`20`	`20`
`21`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(mce);`
	`21`	`+ TSource result = await provider.ExecuteAsync<TSource>(mce);`
`22`	`22`
`23`		`- return result.First();`
	`23`	`+ return result;`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`return query.First();`
`@@ -30,11 +30,11 @@ public static async Task<TSource> FirstAsync<TSource>(this IQueryable<TSource> q`
`30`	`30`	`{`
`31`	`31`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`32`	`32`	`{`
`33`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`33`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`34`	`34`	`null,`
`35`	`35`	`GetMethod<TSource>(nameof(Queryable.First), 2), query.Expression, predicate));`
`36`	`36`
`37`		`- return result.First();`
	`37`	`+ return result;`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`return query.First(predicate);`
`@@ -44,11 +44,11 @@ public static async Task<TSource> FirstOrDefaultAsync<TSource>(this IQueryable<T`
`44`	`44`	`{`
`45`	`45`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`46`	`46`	`{`
`47`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`47`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`48`	`48`	`null,`
`49`	`49`	`GetMethod<TSource>(nameof(Queryable.FirstOrDefault), 1), query.Expression));`
`50`	`50`
`51`		`- return result.FirstOrDefault();`
	`51`	`+ return result;`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`return query.FirstOrDefault();`
`@@ -58,11 +58,11 @@ public static async Task<TSource> FirstOrDefaultAsync<TSource>(this IQueryable<T`
`58`	`58`	`{`
`59`	`59`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`60`	`60`	`{`
`61`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`61`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`62`	`62`	`null,`
`63`	`63`	`GetMethod<TSource>(nameof(Queryable.FirstOrDefault), 2), query.Expression, predicate));`
`64`	`64`
`65`		`- return result.FirstOrDefault();`
	`65`	`+ return result;`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`return query.FirstOrDefault(predicate);`
`@@ -72,11 +72,11 @@ public static async Task<TSource> SingleAsync<TSource>(this IQueryable<TSource>`
`72`	`72`	`{`
`73`	`73`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`74`	`74`	`{`
`75`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`75`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`76`	`76`	`null,`
`77`	`77`	`GetMethod<TSource>(nameof(Queryable.Single), 1), query.Expression));`
`78`	`78`
`79`		`- return result.Single();`
	`79`	`+ return result;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`return query.Single();`
`@@ -86,11 +86,11 @@ public static async Task<TSource> SingleAsync<TSource>(this IQueryable<TSource>`
`86`	`86`	`{`
`87`	`87`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`88`	`88`	`{`
`89`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`89`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`90`	`90`	`null,`
`91`	`91`	`GetMethod<TSource>(nameof(Queryable.Single), 2), query.Expression, predicate));`
`92`	`92`
`93`		`- return result.Single();`
	`93`	`+ return result;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`return query.Single(predicate);`
`@@ -100,11 +100,11 @@ public static async Task<TSource> SingleOrDefaultAsync<TSource>(this IQueryable<`
`100`	`100`	`{`
`101`	`101`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`102`	`102`	`{`
`103`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`103`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`104`	`104`	`null,`
`105`	`105`	`GetMethod<TSource>(nameof(Queryable.SingleOrDefault), 1), query.Expression));`
`106`	`106`
`107`		`- return result.SingleOrDefault();`
	`107`	`+ return result;`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`return query.SingleOrDefault();`
`@@ -114,11 +114,11 @@ public static async Task<TSource> SingleOrDefaultAsync<TSource>(this IQueryable<`
`114`	`114`	`{`
`115`	`115`	`if (query.Provider is SolrQueryProvider<TSource> provider)`
`116`	`116`	`{`
`117`		`- SolrQueryResults<TSource> result = await provider.ExecuteAsync(Expression.Call(`
	`117`	`+ TSource result = await provider.ExecuteAsync<TSource>(Expression.Call(`
`118`	`118`	`null,`
`119`	`119`	`GetMethod<TSource>(nameof(Queryable.SingleOrDefault), 2), query.Expression, predicate));`
`120`	`120`
`121`		`- return result.SingleOrDefault();`
	`121`	`+ return result;`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`return query.SingleOrDefault(predicate);`
Original file line number	Diff line number	Diff line change
`@@ -17,14 +17,14 @@ public static SolrQuery<T> AsQueryable<T>(this ISolrBasicReadOnlyOperations<T> o`
`17`	`17`
`18`	`18`	`public static SolrQueryResults<T> ToSolrQueryResults<T>(this IQueryable<T> queryable)`
`19`	`19`	`{`
`20`		`- return queryable.Provider.Execute(queryable.Expression) as SolrQueryResults<T>;`
	`20`	`+ return (SolrQueryResults<T>)queryable.Provider.Execute(queryable.Expression);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public static Task<SolrQueryResults<T>> ToSolrQueryResultsAsync<T>(this IQueryable<T> queryable)`
`24`	`24`	`{`
`25`	`25`	`if (queryable.Provider is SolrQueryProvider<T> solrProvider)`
`26`	`26`	`{`
`27`		`- return solrProvider.ExecuteAsync(queryable.Expression);`
	`27`	`+ return solrProvider.ExecuteAsync<SolrQueryResults<T>>(queryable.Expression);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`return Task.FromResult(ToSolrQueryResults(queryable));`
Original file line number	Diff line number	Diff line change
`@@ -51,12 +51,16 @@ public IQueryable<TElement> CreateQuery<TElement>(Expression expression)`
`51`	`51`
`52`	`52`	`public object Execute(Expression expression)`
`53`	`53`	`{`
`54`		`- SolrQueryTranslator translator = new SolrQueryTranslator(this.Options, this.MemberContext);`
`55`		`- Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = translator.Translate(this, expression);`
`56`		`- this.Options.SetupQueryOptions?.Invoke(result.Item2);`
	`54`	`+ Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = Translate(expression);`
	`55`	`+`
`57`	`56`	`SolrQueryResults<TEntity> solrQueryResults =`
`58`	`57`	`Operations.Query(this.Options.MainQuery ?? result.Item1, result.Item2);`
`59`	`58`
	`59`	`+ return HandleResults(result, solrQueryResults);`
	`60`	`+ }`
	`61`	`+`
	`62`	`+ private static object HandleResults(Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result, SolrQueryResults<TEntity> solrQueryResults)`
	`63`	`+ {`
`60`	`64`	`switch (result.Item3)`
`61`	`65`	`{`
`62`	`66`	`case EnumeratedResult.First: return solrQueryResults.First();`
`@@ -68,6 +72,14 @@ public object Execute(Expression expression)`
`68`	`72`	`}`
`69`	`73`	`}`
`70`	`74`
	`75`	`+ private Tuple<ISolrQuery, QueryOptions, EnumeratedResult> Translate(Expression expression)`
	`76`	`+ {`
	`77`	`+ SolrQueryTranslator translator = new SolrQueryTranslator(this.Options, this.MemberContext);`
	`78`	`+ Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = translator.Translate(this, expression);`
	`79`	`+ this.Options.SetupQueryOptions?.Invoke(result.Item2);`
	`80`	`+ return result;`
	`81`	`+ }`
	`82`	`+`
`71`	`83`	`public MemberContext MemberContext`
`72`	`84`	`{`
`73`	`85`	`get`
`@@ -79,25 +91,37 @@ public MemberContext MemberContext`
`79`	`91`	`}`
`80`	`92`	`}`
`81`	`93`
`82`		`- public Task<SolrQueryResults<TEntity>> ExecuteAsync(Expression expression)`
	`94`	`+ public async Task<object> ExecuteAsync(Expression expression)`
`83`	`95`	`{`
`84`		`- SolrQueryTranslator`
`85`		`- translator = new SolrQueryTranslator(this.Options, this.MemberContext);`
`86`		`- var result = translator.Translate(this, expression);`
`87`		`- this.Options.SetupQueryOptions?.Invoke(result.Item2);`
`88`		`-`
`89`		`- return Operations.QueryAsync(this.Options.MainQuery ?? result.Item1, result.Item2);`
	`96`	`+ Tuple<ISolrQuery, QueryOptions, EnumeratedResult> result = Translate(expression);`
	`97`	`+`
	`98`	`+ SolrQueryResults<TEntity> solrQueryResults =`
	`99`	`+ await Operations.QueryAsync(this.Options.MainQuery ?? result.Item1, result.Item2);`
	`100`	`+`
	`101`	`+ return HandleResults(result, solrQueryResults);`
`90`	`102`	`}`
`91`	`103`
`92`	`104`	`public TResult Execute<TResult>(Expression expression)`
`93`	`105`	`{`
`94`	`106`	`object providerResult = this.Execute(expression);`
`95`	`107`
	`108`	`+ return CastResult<TResult>(providerResult);`
	`109`	`+ }`
	`110`	`+`
	`111`	`+ public async Task<TResult> ExecuteAsync<TResult>(Expression expression)`
	`112`	`+ {`
	`113`	`+ object providerResult = await this.ExecuteAsync(expression);`
	`114`	`+`
	`115`	`+ return CastResult<TResult>(providerResult);`
	`116`	`+ }`
	`117`	`+`
	`118`	`+ private static TResult CastResult<TResult>(object providerResult)`
	`119`	`+ {`
`96`	`120`	`TResult result = default(TResult);`
`97`	`121`
`98`	`122`	`try`
`99`	`123`	`{`
`100`		`- result = (TResult)providerResult;`
	`124`	`+ result = (TResult) providerResult;`
`101`	`125`	`}`
`102`	`126`	`catch (InvalidCastException exception)`
`103`	`127`	`{`
`@@ -110,6 +134,6 @@ public TResult Execute<TResult>(Expression expression)`
`110`	`134`	`}`
`111`	`135`
`112`	`136`	`return result;`
`113`		`- }`
	`137`	`+ }`
`114`	`138`	`}`
`115`	`139`	`}`