Add Async + Fix Reader Issue + Fix Cast + Fix GetModel + Fix Execute for BatchDelete

Add Async + Fix Reader Issue + Fix Cast + Fix GetModel + Fix Execute for
BatchDelete

Author: zzzprojects

src/shared/Z.EF.Plus.Audit.Shared/Extensions/DbSet`AuditEntry/SaveChanges - Copy (2).cs.bak

@@ -0,0 +1,39 @@
+// 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 EF5 || EF6
+using System.Data.Entity;
+
+#elif EFCORE
+using Microsoft.Data.Entity;
+
+#endif
+
+namespace Z.EntityFramework.Plus
+{
+    public static partial class AuditExtensions
+    {
+        /// <summary>Audits and saves all changes made in this context to the underlying database.</summary>
+        /// <param name="context">The context used to audits and saves all changes made.</param>
+        /// <param name="audit">The audit to use to add changes made to the context.</param>
+        /// <returns>The number of objects written to the underlying database.</returns>-
+        public static int SaveChanges(this DbContext context, Audit audit)
+        {
+            audit.PreSaveChanges(context);
+            var rowAffecteds = context.SaveChanges();
+            audit.PostSaveChanges();
+
+            if (audit.CurrentOrDefaultConfiguration.AutoSavePreAction != null)
+            {
+                audit.CurrentOrDefaultConfiguration.AutoSavePreAction(context, audit);
+                context.SaveChanges();
+            }
+
+            return rowAffecteds;
+        }
+    }
+}

src/shared/Z.EF.Plus.BatchDelete.Shared/BatchDelete.cs

@@ -201,6 +201,11 @@ public int Execute<T>(IQueryable<T> query) where T : class
                     innerObjectQuery.Context.Connection.Open();
                 }
 
+                if (Executing != null)
+                {
+                    Executing(command);
+                }
+
                 if (command.GetType().Name == "NpgsqlCommand")
                 {
                     command.CommandText = command.CommandText.Replace("[", "\"").Replace("]", "\"");
@@ -224,11 +229,6 @@ public int Execute<T>(IQueryable<T> query) where T : class
                 }
                 else
                 {
-                    if (Executing != null)
-                    {
-                        Executing(command);
-                    }
-
                     var rowAffecteds = (int)command.ExecuteScalar();
                     return rowAffecteds;
                 }
@@ -272,6 +272,11 @@ public int Execute<T>(IQueryable<T> query) where T : class
                     dbContext.Database.OpenConnection();
                 }
 
+                if (Executing != null)
+                {
+                    Executing(command);
+                }
+
                 if (command.GetType().Name == "NpgsqlCommand")
                 {
                     command.CommandText = command.CommandText.Replace("[", "\"").Replace("]", "\"");
@@ -283,13 +288,6 @@ public int Execute<T>(IQueryable<T> query) where T : class
                     int totalRowAffecteds = command.ExecuteNonQuery();
                     return totalRowAffecteds;
                 }
-                else
-                {
-                    if (Executing != null)
-                    {
-                        Executing(command);
-                    }
-                }
 
                 var rowAffecteds = (int)command.ExecuteScalar();
                 return rowAffecteds;

src/shared/Z.EF.Plus.BatchUpdate.Shared/BatchUpdate.cs

@@ -847,6 +847,7 @@ public List<Tuple<string, object>> GetInnerValues<T>(IQueryable<T> query, Expres
 
                     // Add the destination name
                     valueSql = valueSql.Replace("AS [C1]", "");
+                    valueSql = valueSql.Replace("AS `C1`", "");
 
                     var listReplace = new List<string>()
                     {
@@ -865,6 +866,21 @@ public List<Tuple<string, object>> GetInnerValues<T>(IQueryable<T> query, Expres
                         "[Filter4]",
                         "[Filter5]",
                         "[Filter6]",
+                        "`Extent1`",
+                        "`Extent2`",
+                        "`Extent3`",
+                        "`Extent4`",
+                        "`Extent5`",
+                        "`Extent6`",
+                        "`Extent7`",
+                        "`Extent8`",
+                        "`Extent9`",
+                        "`Filter1`",
+                        "`Filter2`",
+                        "`Filter3`",
+                        "`Filter4`",
+                        "`Filter5`",
+                        "`Filter6`",
                     };
 
                     // Replace the first value found only!
@@ -883,6 +899,11 @@ public List<Tuple<string, object>> GetInnerValues<T>(IQueryable<T> query, Expres
                         valueSql = valueSql.Substring(0, valueSql.LastIndexOf('[') - 4);
                     }
 
+                    if (valueSql.LastIndexOf('`') != -1 && valueSql.Substring(0, valueSql.LastIndexOf('`')).EndsWith(" AS ", StringComparison.InvariantCulture))
+                    {
+                        valueSql = valueSql.Substring(0, valueSql.LastIndexOf('`') - 4);
+                    }
+
 #elif EFCORE
                     RelationalQueryContext queryContext;
                     var command = ((IQueryable)result).CreateCommand(out queryContext);

src/shared/Z.EF.Plus.QueryFuture.Shared/BaseQueryFuture.cs

@@ -160,11 +160,14 @@ public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQuer
                 logger = loggerField.GetValue(queryCompilationContextFactory);
             }
 
+
             // CREATE connection
             {
                 QueryConnection = context.Database.GetService<IRelationalConnection>();
+               
                 var innerConnection = new CreateEntityConnection(QueryConnection.DbConnection, null);
                 var innerConnectionField = typeof(RelationalConnection).GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
+
                 innerConnectionField.SetValue(QueryConnection, new Microsoft.EntityFrameworkCore.Internal.LazyRef<DbConnection>(() => innerConnection));
             }
 

src/shared/Z.EF.Plus.QueryFuture.Shared/QueryFutureBatch.cs

@@ -12,7 +12,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
-
+using System.Threading.Tasks;
 #if EF5
 using System.Data.EntityClient;
 using System.Data.Objects;
@@ -25,6 +25,7 @@
 #elif EFCORE
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Storage;
 
 #endif
 
@@ -163,12 +164,113 @@ public void ExecuteQueries()
             }
         }
 
+#if NET45
+        /// <summary>Executes deferred query lists.</summary>
+        public async Task ExecuteQueriesAsync()
+        {
+            if (Queries.Count == 0)
+            {
+                // Already all executed
+                return;
+            }
+
+#if EFCORE
+            if (IsInMemory)
+            {
+                foreach (var query in Queries)
+                {
+                    query.ExecuteInMemory();
+                }
+                Queries.Clear();
+                return;
+            }
+#endif
+
+            if (Queries.Count == 1)
+            {
+                Queries[0].GetResultDirectly();
+                Queries.Clear();
+                return;
+            }
+
+#if EF5 || EF6
+            var connection = (EntityConnection)Context.Connection;
+#elif EFCORE
+            if (IsInMemory)
+            {
+                foreach (var query in Queries)
+                {
+                    query.ExecuteInMemory();
+                }
+                return;
+            }
+
+            var connection = Context.Database.GetDbConnection();
+#endif
+            var command = CreateCommandCombined();
+
+            var ownConnection = false;
+
+            try
+            {
+                if (connection.State != ConnectionState.Open)
+                {
+                    await connection.OpenAsync().ConfigureAwait(false);
+                    ownConnection = true;
+                }
+
+                using (command)
+                {
+#if EF5
+                    using (var reader = command.ExecuteReader())
+                    {
+                        foreach (var query in Queries)
+                        {
+                            query.SetResult(reader);
+                            await reader.NextResultAsync().ConfigureAwait(false);
+                        }
+}
+#elif EF6
+                    var interceptionContext = Context.GetInterceptionContext();
+                    using (var reader = DbInterception.Dispatch.Command.Reader(command, new DbCommandInterceptionContext(interceptionContext)))
+                    {
+                        foreach (var query in Queries)
+                        {
+                            query.SetResult(reader);
+                            await reader.NextResultAsync().ConfigureAwait(false);
+                        }
+                    }
+#elif EFCORE
+                    using (var reader = command.ExecuteReader())
+                    {
+                        var createEntityDataReader = new CreateEntityDataReader(reader);
+                        foreach (var query in Queries)
+                        {
+                            query.SetResult(createEntityDataReader);
+                            await reader.NextResultAsync().ConfigureAwait(false);
+                        }
+                    }
+#endif
+                }
+
+                Queries.Clear();
+            }
+            finally
+            {
+                if (ownConnection)
+                {
+                    connection.Close();
+                }
+            }
+        }
+#endif
+
         /// <summary>Creates a new command combining deferred queries.</summary>
         /// <returns>The combined command created from deferred queries.</returns>
         protected DbCommand CreateCommandCombined()
         {
             var command = Context.CreateStoreCommand();
-
+         
             var sb = new StringBuilder();
             var queryCount = 1;
 
@@ -232,7 +334,7 @@ protected DbCommand CreateCommandCombined()
                     }
                 }
 #elif EFCORE
-
+         
                 RelationalQueryContext queryContext;
                 var queryCommand = query.CreateExecutorAndGetCommand(out queryContext);
                 var sql = queryCommand.CommandText;

src/shared/Z.EF.Plus.QueryFuture.Shared/QueryFutureEnumerable.cs

@@ -9,6 +9,7 @@
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Linq;
+using System.Threading.Tasks;
 #if EF5
 using System.Data.Objects;
 
@@ -74,6 +75,53 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
+#if NET45 
+        public async Task<List<T>> ToListAsync()
+        {
+            if (!HasValue)
+            {
+                await OwnerBatch.ExecuteQueriesAsync().ConfigureAwait(false);
+            }
+
+            if (_result == null)
+            {
+                return new List<T>();
+            }
+
+            using (var enumerator = _result.GetEnumerator())
+            {
+                var list = new List<T>();
+                while (enumerator.MoveNext())
+                {
+                    list.Add(enumerator.Current);
+                }
+                return list;
+            }
+        }
+
+        public async Task<T[]> ToArrayAsync()
+        {
+            if (!HasValue)
+            {
+                await OwnerBatch.ExecuteQueriesAsync().ConfigureAwait(false);
+            }
+
+            if (_result == null)
+            {
+                return new T[0];
+            }
+
+            using (var enumerator = _result.GetEnumerator())
+            {
+                var list = new List<T>();
+                while (enumerator.MoveNext())
+                {
+                    list.Add(enumerator.Current);
+                }
+                return list.ToArray();
+            }
+        }
+#endif
 
         /// <summary>Sets the result of the query deferred.</summary>
         /// <param name="reader">The reader returned from the query execution.</param>

src/shared/Z.EF.Plus.QueryFuture.Shared/QueryFutureValue.cs

@@ -10,6 +10,7 @@
 using System.Data;
 using System.Data.Common;
 using System.Linq;
+using System.Threading.Tasks;
 #if EF5
 using System.Data.Objects;
 
@@ -65,6 +66,20 @@ public TResult Value
             }
         }
 
+#if NET45 
+        /// <summary>Gets the value of the future query.</summary>
+        /// <value>The value of the future query.</value>
+        public async Task<TResult> ValueAsync()
+        {
+            if (!HasValue)
+            {
+                await OwnerBatch.ExecuteQueriesAsync().ConfigureAwait(false);
+            }
+
+            return _result;
+        }
+#endif
+
         /// <summary>Sets the result of the query deferred.</summary>
         /// <param name="reader">The reader returned from the query execution.</param>
         public override void SetResult(DbDataReader reader)

src/shared/Z.EF.Plus.QueryIncludeFilter.Shared/QueryIncludeFilterParentQueryable`.cs

@@ -179,7 +179,9 @@ public IQueryable CreateQueryable()
 
                 if (newQuery == null)
                 {
-                    newQuery = OriginalQueryable.Select(x => new {x, q = childQuery});
+                    // REFLECTION: newQuery.CreateAnonymousFromQuery<TElement>(newQuery, childQuery);
+                    var createAnonymousFromQueryMethodGeneric = createAnonymousFromQueryMethod.MakeGenericMethod(OriginalQueryable.ElementType, childQuery.ElementType);
+                    newQuery = (IQueryable)createAnonymousFromQueryMethodGeneric.Invoke(this, new object[] { OriginalQueryable, childQuery });
                 }
                 else
                 {

src/shared/Z.EF.Plus._Core.Shared/EFCore/CreateEntity/CreateEntityCommand.cs

@@ -98,7 +98,7 @@ protected override DbParameter CreateDbParameter()
 
         protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
         {
-            return OriginalDataReader;
+            return OriginalDataReader == null || OriginalDataReader.IsClosed ? OriginalCommand.ExecuteReader(behavior) : OriginalDataReader;
         }
     }
 }