Update source for EF Core 3.x

JonathanMagnan · JonathanMagnan · commit 0fc39574cda7 · 2019-06-10T10:01:59.000-04:00
diff --git a/src/Z.EntityFramework.Plus.EFCore3x.NETStandard20/Z.EntityFramework.Plus.EFCore3x.NETStandard20.csproj b/src/Z.EntityFramework.Plus.EFCore3x.NETStandard20/Z.EntityFramework.Plus.EFCore3x.NETStandard20.csproj
@@ -0,0 +1,62 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup Label="Globals">
+    <SccProjectName>SAK</SccProjectName>
+    <SccProvider>SAK</SccProvider>
+    <SccAuxPath>SAK</SccAuxPath>
+    <SccLocalPath>SAK</SccLocalPath>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <AssemblyName>Z.EntityFramework.Plus.EFCore</AssemblyName>
+    <RootNamespace>Z.EntityFramework.Plus.EFCore.NETStandard20</RootNamespace>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>zzzproject.pfx</AssemblyOriginatorKeyFile>
+    <PackageId>Z.EntityFramework.Plus.EFCore</PackageId>
+    <Version>3.0.0</Version>
+    <Authors>Z.EntityFramework.Plus.EFCore</Authors>
+    <Company>Z.EntityFramework.Plus.EFCore</Company>
+    <Product>Z.EntityFramework.Plus.EFCore</Product>
+    <Description>Description: EF Bulk Operations &amp; Utilities | Bulk Insert, Update, Delete, Merge from database.</Description>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineConstants>TRACE;RELEASE;NETSTANDARD2_0;EFCORE NET45 FULL EFCORE_3X</DefineConstants>
+    <DocumentationFile>bin\Release\netstandard2.0\Z.EntityFramework.Plus.EFCore.xml</DocumentationFile>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DefineConstants>TRACE;NETSTANDARD2_0;EFCORE NET45 FULL;NETSTANDARD2_0;EFCORE_3X</DefineConstants>
+  </PropertyGroup>
+
+  <Import Project="..\shared\Z.EF.Plus._Core.Shared\Z.EF.Plus._Core.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus._ExceptionMessage.Shared\Z.EF.Plus._ExceptionMessage.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.Audit.Shared\Z.EF.Plus.Audit.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.BatchDelete.Shared\Z.EF.Plus.BatchDelete.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.BatchUpdate.Shared\Z.EF.Plus.BatchUpdate.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryCache.Shared\Z.EF.Plus.QueryCache.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryDeferred.Shared\Z.EF.Plus.QueryDeferred.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryExtensions.Shared\Z.EF.Plus.QueryExtensions.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryFilter.Shared\Z.EF.Plus.QueryFilter.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryFuture.Shared\Z.EF.Plus.QueryFuture.Shared.projitems" Label="Shared" />
+
+  <Import Project="..\shared\Z.EF.Plus.QueryIncludeFilterCore.Shared\Z.EF.Plus.QueryIncludeFilterCore.Shared.projitems" Label="Shared" />
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CSharp" Version="4.6.0-preview5.19224.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="3.0.0-preview5.19227.1" />
+    <PackageReference Include="System.Reflection.Emit" Version="4.3.0" />
+    <PackageReference Include="System.Reflection.TypeExtensions" Version="4.6.0-preview5.19224.8" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Z.EntityFramework.Plus.EFCore3x.NETStandard20/Z.EntityFramework.Plus.EFCore3x.NETStandard20.csproj.vspscc b/src/Z.EntityFramework.Plus.EFCore3x.NETStandard20/Z.EntityFramework.Plus.EFCore3x.NETStandard20.csproj.vspscc
@@ -0,0 +1,10 @@
+﻿""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
+}
diff --git a/src/shared/Z.EF.Plus.QueryFuture.Shared/BaseQueryFuture.cs b/src/shared/Z.EF.Plus.QueryFuture.Shared/BaseQueryFuture.cs
@@ -37,7 +37,11 @@
 using Microsoft.EntityFrameworkCore.Query.Expressions;
 using Remotion.Linq.Clauses;
 using Microsoft.EntityFrameworkCore.Query.Sql;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 
+#endif
+#if EFCORE_3X
+using IEvaluatableExpressionFilter = Microsoft.EntityFrameworkCore.Query.Internal.IEvaluatableExpressionFilter;
 #endif
 
 namespace Z.EntityFramework.Plus
@@ -89,6 +93,8 @@ public virtual void ExecuteInMemory()
         /// <returns>The new executor and get command.</returns>
         public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQueryContext queryContext)
         {
+            queryContext = null;
+
             bool isEFCore2x = false;
             bool EFCore_2_1 = false;
 #if EFCORE
@@ -234,15 +240,11 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                 var innerConnectionField = typeof(RelationalConnection).GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
                 var initalConnection = innerConnectionField.GetValue(QueryConnection);
 
-                if (EFCoreHelper.IsVersion3xPreview5)
-                {
-                    innerConnectionField.SetValue(QueryConnection, innerConnection);
-                }
-                else
-                {
-                    innerConnectionField.SetValue(QueryConnection, LazyHelper.NewLazy<DbConnection>(() => innerConnection));
-                }
-                
+#if EFCORE_3X
+                innerConnectionField.SetValue(QueryConnection, innerConnection);
+#else
+                innerConnectionField.SetValue(QueryConnection, LazyHelper.NewLazy<DbConnection>(() => innerConnection));
+#endif
 
                 RestoreConnection = () => innerConnectionField.SetValue(QueryConnection, initalConnection);
             }
@@ -254,28 +256,45 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                 var relationalQueryContextConstructor = relationalQueryContextType.GetConstructors()[0];
 
                 // EF Core 1.1 preview
-                if (relationalQueryContextConstructor.GetParameters().Length == 5)
+                if (isEFCore3x)
                 {
                     // 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 = LazyHelper.NewLazy(() => stateManager);
+                    var dependenciesProperty3 = typeof(RelationalQueryContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
+                    var dependencies3 = dependenciesProperty3.GetValue(queryContextFactory);
+
+                    queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { dependencies3, createQueryBufferDelegate, QueryConnection, executionStrategyFactory });
+                }
+                else if (relationalQueryContextConstructor.GetParameters().Length == 5)
+                {
+                    // 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);
 
+#if !EFCORE_3X
+                    var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, QueryConnection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
+#endif
+
+
+
                 }
                 else if(isEFCore2x)
                 {
                     // 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);
 
+#if !EFCORE_3X
                     var lazyRefStateManager = LazyHelper.NewLazy(() => stateManager);
 
                     var dependenciesProperty3 = typeof(RelationalQueryContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
                     var dependencies3 = dependenciesProperty3.GetValue(queryContextFactory);
 
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { dependencies3, createQueryBufferDelegate, QueryConnection, executionStrategyFactory });
+#endif
                 }
                 else
                 {
@@ -284,16 +303,18 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
             }
 
 
-            Expression newQuery;
+            Expression newQuery = null;
 
             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(Query.Expression);
+#if EFCORE_3X
+                var visitor = new ParameterExtractingExpressionVisitor(evaluatableExpressionFilter, queryContext, queryContext.GetType(), (IDiagnosticsLogger<DbLoggerCategory.Query>)logger, true, false);
+                newQuery = visitor.ExtractParameters(Query.Expression);
+#endif
+                //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(Query.Expression);
             }
             else if(isEFCore2x)
             {
@@ -394,8 +415,8 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
         }
 #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.QueryIncludeFilterCore.Shared/QueryIncludeFilterProvider.cs b/src/shared/Z.EF.Plus.QueryIncludeFilterCore.Shared/QueryIncludeFilterProvider.cs
@@ -145,10 +145,15 @@ public TResult Execute<TResult>(Expression expression)
                 arguments.RemoveAt(1);
             }
 
+#if EFCORE_3X
+            // RESOLE parent queries using .FutureValue();
+            var immediateQuery = new EntityQueryable<TResult>((IAsyncQueryProvider)OriginalProvider, expression);
+#else
             // RESOLE parent queries using .FutureValue();
             var immediateQuery = new EntityQueryable<TResult>((IAsyncQueryProvider)OriginalProvider);
             var expressionProperty = typeof(QueryableBase<>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             expressionProperty.SetValue(immediateQuery, expression);
+#endif
 
             object value = null;
 
@@ -219,46 +224,23 @@ public TResult Execute<TResult>(Expression expression)
             return (TResult)value;
         }
 
+#if EFCORE_3X
+        public TResult ExecuteAsync<TResult>(Expression expression)
+        {
+            throw new Exception(ExceptionMessage.GeneralException);
+        }
+#else
         public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
         {
             throw new Exception(ExceptionMessage.GeneralException);
         }
 
+   
+#endif
         public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
         {
             return Task.Run(() => Execute<TResult>(expression), cancellationToken);
         }
-
-        //public TResult ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
-        //{
-        //    throw new Exception("a");
-        //}
-
-
-        ///// <summary>Executes the given expression asynchronously.</summary>
-        ///// <exception cref="Exception">Thrown when an exception error condition occurs.</exception>
-        ///// <param name="expression">The expression to execute.</param>
-        ///// <param name="cancellationToken">The cancellation token.</param>
-        ///// <returns>The object returned by the execution of the expression.</returns>
-        //public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken)
-        //{
-        //    throw new Exception(ExceptionMessage.GeneralException);
-        //}
-
-        //public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
-        //{
-        //    throw new Exception("TODO: public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)");
-        //    //return Task.Run(() => Execute<TResult>(expression));
-        //}
-
-        ///// <summary>Executes the given expression asynchronously.</summary>
-        ///// <typeparam name="TResult">Type of the result.</typeparam>
-        ///// <param name="expression">The expression to execute.</param>
-        ///// <param name="cancellationToken">The cancellation token.</param>
-        ///// <returns>The object returned by the execution of the expression.</returns>
-        //public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
-        //{
-        //    return Task.Run(() => Execute<TResult>(expression), cancellationToken);
-        //}
+        
     }
 }
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
@@ -36,6 +36,10 @@
 
 #endif
 
+#if EFCORE_3X
+using IEvaluatableExpressionFilter = Microsoft.EntityFrameworkCore.Query.Internal.IEvaluatableExpressionFilter;
+#endif
+
 namespace Z.EntityFramework.Plus
 {
     internal static partial class InternalExtensions
@@ -135,24 +139,31 @@ internal static IEnumerable<T> MapReader<T>(this DbContext context, DbDataReader
             var innerConnection = new CreateEntityConnection(queryConnection.DbConnection, null);
             //QueryConnection.DbConnection = innerConnection;
             var innerConnectionField = typeof(RelationalConnection).GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
-            innerConnectionField.SetValue(queryConnection, new Microsoft.EntityFrameworkCore.Internal.LazyRef<DbConnection>(() => innerConnection));
+
+#if EFCORE_3X
+            innerConnectionField.SetValue(queryConnection, innerConnection);
+#else
+            innerConnectionField.SetValue(queryConnection, LazyHelper.NewLazy<DbConnection>(() => innerConnection));
+#endif
 
             // CREATE query context
-            RelationalQueryContext queryContext;
+            RelationalQueryContext queryContext = null;
             {
                 var relationalQueryContextType = typeof(RelationalQueryContext);
                 var relationalQueryContextConstructor = relationalQueryContextType.GetConstructors()[0];
 
                 // EF Core 1.1 preview
                 if (relationalQueryContextConstructor.GetParameters().Length == 5)
                 {
+#if !EFCORE_3X
                     // 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 = LazyHelper.NewLazy(() => stateManager);
 
                     queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, connection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
+#endif
                 }
                 else
                 {
@@ -200,7 +211,7 @@ internal static IEnumerable<T> MapReader<T>(this DbContext context, DbDataReader
             }
             return list;
 #endif
-        }
+                }
     }
 }
 #endif
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/EFCoreHelper.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/EFCoreHelper.cs
@@ -12,8 +12,13 @@ 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;
+#if EFCORE_3X
+        internal static bool IsVersion3x = true;
+        internal static bool IsVersion3xPreview5 = true;
+#else
+        internal static bool IsVersion3x = false;
+        internal static bool IsVersion3xPreview5 = false;
+#endif
     }
 }
 #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
@@ -20,6 +20,10 @@
 using Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation;
 using Remotion.Linq.Parsing.Structure;
 
+#if EFCORE_3X
+using IEvaluatableExpressionFilter = Microsoft.EntityFrameworkCore.Query.Internal.IEvaluatableExpressionFilter;
+#endif
+
 namespace Z.EntityFramework.Plus
 {
     internal static partial class InternalExtensions
@@ -110,7 +114,12 @@ public static IRelationalCommand CreateCommand<T>(this IQueryable<T> source, out
             var queries = queryModelVisitor.Queries;
             var sqlQuery = queries.ToList()[0];
 
+#if EFCORE_3X
+            var commandBuilderFactory = queryContext.Context.Database.GetService<IRelationalCommandBuilderFactory>();
+            var command = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(commandBuilderFactory, queryContext.ParameterValues, null);
+#else
             var command = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(queryContext.ParameterValues);
+#endif
 
             return command;
         }
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
diff --git a/src/shared/Z.EF.Plus._Core.Shared/EFCore/LazyHelper.cs b/src/shared/Z.EF.Plus._Core.Shared/EFCore/LazyHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,13 @@ namespace Z.EntityFramework.Plus`
`12`	`12`	`{`
`13`	`13`	`internal static partial class EFCoreHelper`
`14`	`14`	`{`
`15`		`- internal static bool IsVersion3x = typeof(IQuerySqlGenerator).GetMethod("GenerateSql").GetParameters().Length == 3;`
`16`		- internal static bool IsVersion3xPreview5 = IsVersion3x && typeof(DbContext).Assembly.GetType("Microsoft.EntityFrameworkCore.Internal.LazyRef`1") == null;
	`15`	`+#if EFCORE_3X`
	`16`	`+ internal static bool IsVersion3x = true;`
	`17`	`+ internal static bool IsVersion3xPreview5 = true;`
	`18`	`+#else`
	`19`	`+ internal static bool IsVersion3x = false;`
	`20`	`+ internal static bool IsVersion3xPreview5 = false;`
	`21`	`+#endif`
`17`	`22`	`}`
`18`	`23`	`}`
`19`	`24`	`#endif`