Fix EF Core Preview5

JonathanMagnan · JonathanMagnan · commit f151e37ce83c · 2019-05-21T08:55:16.000-04:00
diff --git a/src/shared/Z.EF.Plus.QueryDeferred.Shared/QueryDeferred.cs b/src/shared/Z.EF.Plus.QueryDeferred.Shared/QueryDeferred.cs
@@ -48,9 +48,18 @@ public QueryDeferred(IQueryable query, Expression expression)
             var createQueryMethod = provider.GetType().GetMethod("CreateQuery", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Expression), typeof(Type) }, null);
             Query = (IQueryable<TResult>)createQueryMethod.Invoke(provider, new object[] { expression, typeof(TResult) });
 #elif EFCORE
-            Query = new EntityQueryable<TResult>((IAsyncQueryProvider)query.Provider);
-            var expressionProperty = typeof(QueryableBase<>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-            expressionProperty.SetValue(Query, expression);
+            if (EFCoreHelper.IsVersion3x)
+            {
+                // EF Core 3.x
+                Query = new EntityQueryable<TResult>((IAsyncQueryProvider)query.Provider, Expression);
+            }
+            else
+            {
+                // EF Core 2.x
+                Query = new EntityQueryable<TResult>((IAsyncQueryProvider)query.Provider);
+                var expressionProperty = typeof(QueryableBase<>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                expressionProperty.SetValue((QueryableBase<TResult>)Query, expression);
+            }
 #endif
         }
 
diff --git a/src/shared/Z.EF.Plus.QueryFuture.Shared/BaseQueryFuture.cs b/src/shared/Z.EF.Plus.QueryFuture.Shared/BaseQueryFuture.cs
@@ -36,6 +36,7 @@
 using Remotion.Linq.Parsing.Structure;
 using Microsoft.EntityFrameworkCore.Query.Expressions;
 using Remotion.Linq.Clauses;
+using Microsoft.EntityFrameworkCore.Query.Sql;
 
 #endif
 
@@ -90,6 +91,9 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
         {
             bool isEFCore2x = false;
             bool EFCore_2_1 = false;
+#if EFCORE
+            bool isEFCore3x = EFCoreHelper.IsVersion3x;
+#endif
 
             var context = Query.GetDbContext();
 
@@ -155,7 +159,11 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
 #if NETSTANDARD2_0
             IEvaluatableExpressionFilter evaluatableExpressionFilter = null;
 
-            if (EFCore_2_1)
+            if (isEFCore3x)
+            {
+                evaluatableExpressionFilter = (RelationalEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetProperty("EvaluatableExpressionFilter", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
+            }
+            else if (EFCore_2_1)
             {
                 evaluatableExpressionFilter = (IEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
             }
@@ -226,7 +234,15 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                 var innerConnectionField = typeof(RelationalConnection).GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
                 var initalConnection = innerConnectionField.GetValue(QueryConnection);
 
-                innerConnectionField.SetValue(QueryConnection, new Microsoft.EntityFrameworkCore.Internal.LazyRef<DbConnection>(() => innerConnection));
+                if (EFCoreHelper.IsVersion3xPreview5)
+                {
+                    innerConnectionField.SetValue(QueryConnection, innerConnection);
+                }
+                else
+                {
+                    innerConnectionField.SetValue(QueryConnection, LazyHelper.NewLazy<DbConnection>(() => innerConnection));
+                }
+                
 
                 RestoreConnection = () => innerConnectionField.SetValue(QueryConnection, initalConnection);
             }
@@ -244,7 +260,7 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                     var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
                     var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
 
-                    var lazyRefStateManager = new LazyRef<IStateManager>(() => stateManager);
+                    var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
 
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, QueryConnection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
                 }
@@ -254,7 +270,7 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                     var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
                     var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
 
-                    var lazyRefStateManager = new LazyRef<IStateManager>(() => stateManager);
+                    var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
 
                     var dependenciesProperty3 = typeof(RelationalQueryContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
                     var dependencies3 = dependenciesProperty3.GetValue(queryContextFactory);
@@ -270,8 +286,16 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
 
             Expression newQuery;
 
+            if (isEFCore3x)
+            {
+                var parameterExtractingExpressionVisitorConstructor = typeof(ParameterExtractingExpressionVisitor).GetConstructors().First(x => x.GetParameters().Length == 6);
 
-            if(isEFCore2x)
+                var parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, queryContext.GetType(), logger, true, false });
+
+                // CREATE new query from query visitor
+                newQuery = parameterExtractingExpressionVisitor.ExtractParameters(Query.Expression);
+            }
+            else if(isEFCore2x)
             {
                 var parameterExtractingExpressionVisitorConstructors = typeof(ParameterExtractingExpressionVisitor).GetConstructors();
 
@@ -289,10 +313,9 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
 
 	                var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 6);
 
-					ParameterExtractingExpressionVisitor parameterExtractingExpressionVisitor = null; 
+					ParameterExtractingExpressionVisitor parameterExtractingExpressionVisitor = null;
 
-	                // EF Core 2.1   
-					if (parameterExtractingExpressionVisitorConstructor.GetParameters().Where(x => x.ParameterType == typeof(DbContext)).Any())
+                    if (parameterExtractingExpressionVisitorConstructor.GetParameters().Where(x => x.ParameterType == typeof(DbContext)).Any())
 					{
 						parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, context, true, false });
 					}
@@ -346,14 +369,33 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                 sqlQuery = queryModelVisitor.Queries.First();
             }
 
-            // RETURN the IRealationCommand
+            // RETURN the IRelationalCommand
+#if EFCORE
+            IRelationalCommand relationalCommand = null;
+            var dynamicSqlGenerator = (dynamic)sqlQuery.CreateDefaultQuerySqlGenerator();
+
+            if (isEFCore3x)
+            {
+                var commandBuilderFactory = context.Database.GetService<IRelationalCommandBuilderFactory>();
+                
+                // TODO: Fix null for DbLogger
+                relationalCommand = (IRelationalCommand)dynamicSqlGenerator.GenerateSql(commandBuilderFactory, queryContext.ParameterValues, null);
+            }
+            else
+            {
+                relationalCommand = (IRelationalCommand)dynamicSqlGenerator.GenerateSql(queryContext.ParameterValues);
+            }
+            
+#else
             var relationalCommand = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(queryContext.ParameterValues);
+#endif
+
             return relationalCommand;
         }
 #endif
 
-        /// <summary>Sets the result of the query deferred.</summary>
-        /// <param name="reader">The reader returned from the query execution.</param>
+            /// <summary>Sets the result of the query deferred.</summary>
+            /// <param name="reader">The reader returned from the query execution.</param>
         public virtual void SetResult(DbDataReader reader)
         {
         }
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EF/DbContext/DbContext.MapReader.cs b/src/shared/Z.EF.Plus._Core.Shared/EF/DbContext/DbContext.MapReader.cs
@@ -149,8 +149,8 @@ internal static IEnumerable<T> MapReader<T>(this DbContext context, DbDataReader
                     // REFLECTION: Query.Provider._queryCompiler._queryContextFactory.ExecutionStrategyFactory
                     var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
                     var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
-
-                    var lazyRefStateManager = new LazyRef<IStateManager>(() => stateManager);
+                    
+                    var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
 
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, connection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
                 }
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/EFCoreHelper.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/EFCoreHelper.cs
@@ -0,0 +1,19 @@
+﻿// Description: Entity Framework Bulk Operations & Utilities (EF Bulk SaveChanges, Insert, Update, Delete, Merge | LINQ Query Cache, Deferred, Filter, IncludeFilter, IncludeOptimize | Audit)
+// Website & Documentation: https://github.com/zzzprojects/Entity-Framework-Plus
+// Forum & Issues: https://github.com/zzzprojects/EntityFramework-Plus/issues
+// License: https://github.com/zzzprojects/EntityFramework-Plus/blob/master/LICENSE
+// More projects: http://www.zzzprojects.com/
+// Copyright © ZZZ Projects Inc. 2014 - 2016. All rights reserved.
+
+#if EFCORE
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Query.Sql;
+namespace Z.EntityFramework.Plus
+{
+    internal static partial class EFCoreHelper
+    {
+        internal static bool IsVersion3x = typeof(IQuerySqlGenerator).GetMethod("GenerateSql").GetParameters().Length == 3;
+        internal static bool IsVersion3xPreview5 = IsVersion3x && typeof(DbContext).Assembly.GetType("Microsoft.EntityFrameworkCore.Internal.LazyRef`1") == null;
+    }
+}
+#endif
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/CreateCommand.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/CreateCommand.cs
@@ -15,6 +15,7 @@
 using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.Query.ExpressionVisitors.Internal;
 using Microsoft.EntityFrameworkCore.Query.Internal;
+using Microsoft.EntityFrameworkCore.Query.Sql;
 using Microsoft.EntityFrameworkCore.Storage;
 using Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation;
 using Remotion.Linq.Parsing.Structure;
@@ -117,6 +118,9 @@ public static IRelationalCommand CreateCommand<T>(this IQueryable<T> source, out
         public static IRelationalCommand CreateCommand(this IQueryable source, out RelationalQueryContext queryContext)
         {
             bool EFCore_2_1 = false;
+#if EFCORE
+            bool isEFCore3x = EFCoreHelper.IsVersion3x;
+#endif
 
             var compilerField = typeof(EntityQueryProvider).GetField("_queryCompiler", BindingFlags.NonPublic | BindingFlags.Instance);
             var compiler = compilerField.GetValue(source.Provider);
@@ -158,14 +162,18 @@ public static IRelationalCommand CreateCommand(this IQueryable source, out Relat
 #if NETSTANDARD2_0
            IEvaluatableExpressionFilter evaluatableExpressionFilter = null;
 
-            if (EFCore_2_1)
+           if (isEFCore3x)
+           {
+               evaluatableExpressionFilter = (RelationalEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetProperty("EvaluatableExpressionFilter", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
+           }
+            else if (EFCore_2_1)
             {
                 evaluatableExpressionFilter = (IEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
             }
-            else
-            {
-                evaluatableExpressionFilter = (IEvaluatableExpressionFilter)compiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(queryCompiler);
-            }
+           else
+           {
+               evaluatableExpressionFilter = (IEvaluatableExpressionFilter) compiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(queryCompiler);
+           }
 #else
             var evalutableExpressionFilterField = compiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Static);
             var evalutableExpressionFilter = (IEvaluatableExpressionFilter)evalutableExpressionFilterField.GetValue(null);
@@ -197,7 +205,16 @@ public static IRelationalCommand CreateCommand(this IQueryable source, out Relat
 
                 var parameterExtractingExpressionVisitorConstructors = typeof(ParameterExtractingExpressionVisitor).GetConstructors();
 
-                if (parameterExtractingExpressionVisitorConstructors.Any(x => x.GetParameters().Length == 5))
+                if (isEFCore3x)
+                {
+                    var parameterExtractingExpressionVisitorConstructor = typeof(ParameterExtractingExpressionVisitor).GetConstructors().First(x => x.GetParameters().Length == 6);
+
+                    var parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, queryContext.GetType(), logger, true, false });
+
+                    // CREATE new query from query visitor
+                    newQuery = parameterExtractingExpressionVisitor.ExtractParameters(source.Expression);
+                }
+                else if (parameterExtractingExpressionVisitorConstructors.Any(x => x.GetParameters().Length == 5))
                 {
                     // EF Core 2.1
                     var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 5);
@@ -273,10 +290,21 @@ public static IRelationalCommand CreateCommand(this IQueryable source, out Relat
             var queries = queryModelVisitor.Queries;
             var sqlQuery = queries.ToList()[0];
 
+            IRelationalCommand relationalCommand = null;
+            var dynamicSqlGenerator = (dynamic)sqlQuery.CreateDefaultQuerySqlGenerator();
 
-            var command = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(queryContext.ParameterValues);
+            if (isEFCore3x)
+            {
+                var commandBuilderFactory = queryContext.Context.Database.GetService<IRelationalCommandBuilderFactory>();
+                // TODO: Fix null for DbLogger
+                relationalCommand = (IRelationalCommand)dynamicSqlGenerator.GenerateSql(commandBuilderFactory, queryContext.ParameterValues, null);
+            }
+            else
+            {
+                relationalCommand = (IRelationalCommand)dynamicSqlGenerator.GenerateSql(queryContext.ParameterValues);
+            }
 
-            return command;
+            return relationalCommand;
         }
     }
 }
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/GetDbContext.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/GetDbContext.cs
@@ -48,15 +48,6 @@ public static DbContext GetDbContext<T>(this IQueryable<T> source)
 
             IStateManager stateManager = stateManagerDynamic as IStateManager;
 
-            if (stateManager == null)
-            {
-                Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager> lazyStateManager = stateManagerDynamic as Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager>;
-                if(lazyStateManager != null)
-                {
-                    stateManager = lazyStateManager.Value;
-                }
-            }
-
             if (stateManager == null)
             {
                 stateManager = ((dynamic) stateManagerDynamic).Value;
@@ -101,15 +92,6 @@ public static DbContext GetDbContext(this IQueryable query)
 
             IStateManager stateManager = stateManagerDynamic as IStateManager;
 
-            if (stateManager == null)
-            {
-                Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager> lazyStateManager = stateManagerDynamic as Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager>;
-                if(lazyStateManager != null)
-                {
-                    stateManager = lazyStateManager.Value;
-                }
-            }
-
             if (stateManager == null)
             {
                 stateManager = ((dynamic) stateManagerDynamic).Value;
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/GetInMemoryContext.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/GetInMemoryContext.cs
@@ -46,15 +46,6 @@ public static DbContext GetInMemoryContext<T>(this IQueryable<T> source)
 
 			IStateManager stateManager = stateManagerDynamic as IStateManager;
 
-			if (stateManager == null)
-			{
-				Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager> lazyStateManager = stateManagerDynamic as Microsoft.EntityFrameworkCore.Internal.LazyRef<IStateManager>;
-				if (lazyStateManager != null)
-				{
-					stateManager = lazyStateManager.Value;
-				}
-			}
-
 			if (stateManager == null)
 			{
 				stateManager = ((dynamic)stateManagerDynamic).Value;
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/IQueryable`.GetCommand.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/IQueryable`/IQueryable`.GetCommand.cs
@@ -127,7 +127,7 @@ public static IRelationalCommand GetDbCommand<T>(this IQueryable<T> query)
                     var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
                     var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
 
-                    var lazyRefStateManager = new LazyRef<IStateManager>(() => stateManager);
+                    var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
 
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, connection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
                 }
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/LazyHelper.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/LazyHelper.cs
@@ -0,0 +1,31 @@
+﻿#if EFCORE
+using Microsoft.EntityFrameworkCore;
+using System;
+using Microsoft.EntityFrameworkCore.Internal;
+
+namespace Z.EntityFramework.Plus
+{
+    public class LazyHelper
+    {
+        public static object NewLazy<T>(Func<T> valueFactory)
+        {
+            if (!EFCoreHelper.IsVersion3xPreview5)
+            {
+                return LazyRefHelper.NewLazy<T>(valueFactory);
+            }
+            else
+            {
+                return new Lazy<T>(valueFactory);
+            }
+        }
+    }
+
+    public class LazyRefHelper
+    {
+        public static object NewLazy<T>(Func<T> valueFactory)
+        {
+            return new LazyRef<T>(valueFactory);
+        }
+    }
+}
+#endif
diff --git a/src/shared/Z.EF.Plus._Core.Shared/Z.EF.Plus._Core.Shared.projitems b/src/shared/Z.EF.Plus._Core.Shared/Z.EF.Plus._Core.Shared.projitems

Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ public static IRelationalCommand GetDbCommand<T>(this IQueryable<T> query)`
`127`	`127`	`var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Instance \| BindingFlags.FlattenHierarchy);`
`128`	`128`	`var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);`
`129`	`129`
`130`		`- var lazyRefStateManager = new LazyRef<IStateManager>(() => stateManager);`
	`130`	`+ var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);`
`131`	`131`
`132`	`132`	`queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, connection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });`
`133`	`133`	`}`