关于EF6的记录Sql语句 与 EntityFramework.Extend 的诟病

1、关于EF6的记录Sql语句，一个老生长谈的问题。 他生成的sql语句实在是烂，大家都这样说

2、EF6 更新删除不方便，没有批量操作。所以，有人出了EF6.Extend  大家用起来也很爽

基于以上两点，我也尝试着使用 EF6.Extend 。本以为可以很好的，很美好。没有想到我遇到了一个大问题。

我需要 通过程序记录 EF执行的Sql语句，当然也包括 EF6.Extend 执行的Sql语句。（不是通过SqlProfiler）

在网上查找，发现 了一篇文章，我就这样抄下来了。（太匆忙解决问题，忘记了哪一篇）

继承了 System.Data.Entity.Infrastructure.Interception.DbCommandInterceptor  ，实现相关方法。  然后在Main方法（程序入口）进行添加  DbInterception.Add(new EFIntercepterLogging());   

using System;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure.Interception;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF_Sqlite
{
    class EFIntercepterLogging : DbCommandInterceptor
    {
        private readonly Stopwatch _stopwatch = new Stopwatch();
        public override void ScalarExecuting(System.Data.Common.DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
            base.ScalarExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }
        public override void ScalarExecuted(System.Data.Common.DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                Trace.TraceError("Exception:{1} \r\n --> Error executing command: {0}", command.CommandText, interceptionContext.Exception.ToString());
            }
            else
            {
                string txt=string.Format("\r\n执行时间:{0} 毫秒\r\n-->ScalarExecuted.Command:{1}\r\n", _stopwatch.ElapsedMilliseconds, command.CommandText);
                Console.WriteLine(txt);
                Trace.TraceInformation(txt);
            }
            base.ScalarExecuted(command, interceptionContext);
        }
        public override void NonQueryExecuting(System.Data.Common.DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
            base.NonQueryExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }
        public override void NonQueryExecuted(System.Data.Common.DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
            
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                Trace.TraceError("Exception:{1} \r\n --> Error executing command:\r\n {0}", command.CommandText, interceptionContext.Exception.ToString());
            }
            else
            {   
                
                string txt = string.Format("\r\n执行时间:{0} 毫秒\r\n-->ScalarExecuted.Command:{1}\r\n", _stopwatch.ElapsedMilliseconds, command.CommandText);
                Console.WriteLine(txt);
                Trace.TraceInformation(txt);
            }
            base.NonQueryExecuted(command, interceptionContext);
        }
        public override void ReaderExecuting(System.Data.Common.DbCommand command, DbCommandInterceptionContext<System.Data.Common.DbDataReader> interceptionContext)
        {
            base.ReaderExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }
        public override void ReaderExecuted(System.Data.Common.DbCommand command, DbCommandInterceptionContext<System.Data.Common.DbDataReader> interceptionContext)
        {
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                Trace.TraceError("Exception:{1} \r\n --> Error executing command:\r\n {0}", command.CommandText, interceptionContext.Exception.ToString());
            }
            else
            {
                string txt = string.Format("\r\n执行时间:{0} 毫秒\r\n-->ScalarExecuted.Command:{1}\r\n", _stopwatch.ElapsedMilliseconds, command.CommandText);
                Console.WriteLine(txt);
                Trace.TraceInformation(txt);
            }
            base.ReaderExecuted(command, interceptionContext);
        }

        
    }
}

通过EF正常的操作是可以记录到SQL语句的，而通过EF.Extend执行的删除操作是无法获取sql的。我想，是不是我写错了，可网上根本没有关于EF.Extend 记录生成SQL的只言片语，可能大家都没有遇到这样的问题。  

只能硬着头皮，翻源码。

经过翻看EF.Extend的源码，发现他是直接用Command执行的sql，再翻 EF的源码发现，EF是绕了很大一圈来执行的SQL 

 找到EF的这里，我明白了

public virtual int NonQuery(DbCommand command, DbCommandInterceptionContext interceptionContext)
{
Check.NotNull(command, "command");
Check.NotNull(interceptionContext, "interceptionContext");

return _internalDispatcher.Dispatch(
command,
(t, c) => t.ExecuteNonQuery(),
new DbCommandInterceptionContext<int>(interceptionContext),
(i, t, c) => i.NonQueryExecuting(t, c),
(i, t, c) => i.NonQueryExecuted(t, c));
}

 而，EF.Extend的代码是这样写的

private int InternalDelete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query)
            where TEntity : class
#endif
        {
            DbConnection deleteConnection = null;
            DbTransaction deleteTransaction = null;
            DbCommand deleteCommand = null;
            bool ownConnection = false;
            bool ownTransaction = false;

            try
            {
                // get store connection and transaction
                var store = GetStore(objectContext);
                deleteConnection = store.Item1;
                deleteTransaction = store.Item2;

                if (deleteConnection.State != ConnectionState.Open)
                {
                    deleteConnection.Open();
                    ownConnection = true;
                }

                if (deleteTransaction == null)
                {
                    deleteTransaction = deleteConnection.BeginTransaction();
                    ownTransaction = true;
                }


                deleteCommand = deleteConnection.CreateCommand();
                deleteCommand.Transaction = deleteTransaction;
                if (objectContext.CommandTimeout.HasValue)
                    deleteCommand.CommandTimeout = objectContext.CommandTimeout.Value;

                var innerSelect = GetSelectSql(query, entityMap, deleteCommand);

                var sqlBuilder = new StringBuilder(innerSelect.Length * 2);

                sqlBuilder.Append("DELETE ");
                sqlBuilder.Append(entityMap.TableName);
                sqlBuilder.AppendLine();

                sqlBuilder.AppendFormat("FROM {0} AS j0 INNER JOIN (", entityMap.TableName);
                sqlBuilder.AppendLine();
                sqlBuilder.AppendLine(innerSelect);
                sqlBuilder.Append(") AS j1 ON (");

                bool wroteKey = false;
                foreach (var keyMap in entityMap.KeyMaps)
                {
                    if (wroteKey)
                        sqlBuilder.Append(" AND ");

                    sqlBuilder.AppendFormat("j0.[{0}] = j1.[{0}]", keyMap.ColumnName);
                    wroteKey = true;
                }
                sqlBuilder.Append(")");

                deleteCommand.CommandText = sqlBuilder.ToString();

#if NET45
                int result = async
                    ? await deleteCommand.ExecuteNonQueryAsync().ConfigureAwait(false)
                    : deleteCommand.ExecuteNonQuery();
#else
                int result = deleteCommand.ExecuteNonQuery();
#endif
                // only commit if created transaction
                if (ownTransaction)
                    deleteTransaction.Commit();

                return result;
            }
            finally
            {
                if (deleteCommand != null)
                    deleteCommand.Dispose();

                if (deleteTransaction != null && ownTransaction)
                    deleteTransaction.Dispose();

                if (deleteConnection != null && ownConnection)
                    deleteConnection.Close();
            }
        }

 经过分析，是这个道理，按照这个逻辑，EF.Extend没有按照EF的逻辑写，所以，他不能通过这种方式记录Sql。

恍然大悟后，我这样执行的Sql

System.Data.Common.DbConnection con = t.Database.Connection;
System.Data.Common.DbCommand command = con.CreateCommand();
con.Open();
command.CommandText = "delete from area where 1=2 and 4=9";
DbInterception.Dispatch.Command.NonQuery(command, new DbCommandInterceptionContext());

 就这样，我 通过统一的方式，获取到了我自己执行的Sql语句，和EF执行的Sql语句

本来是打算用EF.Extend的，看到这里，我决定不用了，有点杀鸡用牛刀。（其实，EF.Extend 不仅扩展了修改和删除的方法，还扩展了 EF没有的二级缓存，等等。如果只是用到修改删除的扩展方法，那可以放弃Extend了。）

修改后的DLL文件