连接弹性和命令拦截的 ASP.NET MVC 应用程序中的实体框架

时间：2016-12-03 18:29:22 阅读：289 评论：0 收藏：0 [点我收藏+]

标签：invoke int strategy 连接数 about 解释 str 错误 client

最近悟出来一个道理，在这儿分享给大家：学历代表你的过去，能力代表你的现在，学习代表你的将来。

十年河东十年河西，莫欺少年穷

学无止境，精益求精

上篇博客我们学习了EF 之 MVC 排序，查询，分页 Sorting, Filtering, and Paging For MVC About EF，本节继续学习

标题中的：连接弹性(微软解释：瞬态错误自动重试连接)和命令拦截(捕捉所有 SQL 查询发送到数据库，以便登录或改变它们)

上网查了大量的资料，网友们基本都是直接翻译原文：Connection Resiliency and Command Interception with the Entity Framework in an ASP.NET MVC Application

在解释连接弹性之前，我们来看一段代码：

        /// <summary>
        /// 释放数据库资源 断开连接
        /// </summary>
        /// <param name="disposing"></param>
        protected override void Dispose(bool disposing)
        {
            db.Dispose();
            base.Dispose(disposing);
        }

上述代码意思是SQL操作执行后，及时断开数据库连接，释放数据库资源

SQL操作的过程：SQL操作-->执行时发生异常-->执行Dispose-->断开连接，释放资源。在本次操作中，程序和数据库连接了一次，因为发生异常，及时释放了数据库资源，这样的执行过程看似没问题，但是用户体验不太好。

如果SQL本身没有什么问题，由于断开了数据库连接，用户得不到数据结果，岂不是用户体验差吗？

我们再来看看微软的解读：连接弹性(微软解释：瞬态错误自动重试连接的次数)

微软的意思是，在执行一个SQL的过程中，如果第一次执行错误，还可以通过代码控制来实现重连，进行第二次数据库连接，同理，如果第二次数据连接依然发生异常，还会执行第三次数据库连接等等，而在数据库访问策略中，这样的重试连接默认是四次。

回到刚才的话题：如果SQL语句本身没有什么问题，SQL第一次执行失败，那么第二次就可能成功，这样就提高了用户体验。

在此：举一些例子，例如SQL执行过程中突然断网，访问的资源临时被占用等导致的执行失败都是可以尝试重连的。

OK，关于连接弹性的说明就到这儿，下面我们探讨下命令拦截，首先看微软的解释<捕捉所有 SQL 查询发送到数据库，以便登录或改变它们>

看完微软的解释，相信你和我一样也是丈二的和尚，摸不着头脑。而本人的理解是这样的，当然，我的理解也可能不对，希望大家在评论区指出，谢谢。

我的理解如下：

EF代码很少使用SQL语句，在我们写EF时，基本都用Linq To Sql代替了，而我们访问数据库的最基本单元就是SQL语句，那么你书写的linq To Sql 会转化成什么样的SQL语句呢？如果我们能看到这些SQL语句，我们就可以根据这些SQL语句做一些改变，从而提高程序的效率。

例如：下面的EF代码语句：

        private StudentContext db = new StudentContext();
        /// <summary>
        /// 简单分页演示
        /// </summary>
        /// <param name="page">页码</param>
        /// <returns></returns>
        public ActionResult Index2(int page = 1)//查询所有学生数据
        {
            return View(db.Students.OrderBy(item=>item.Id).ToPagedList(page,9));
        }

上述代码是个简单的分页程序，如果你看不懂，请参照我的上篇博客：EF 之 MVC 排序，查询，分页 Sorting, Filtering, and Paging For MVC About EF

那么上述代码在执行的过程中会生成什么样的SQL语句呢？

技术分享

在程序运行的输出窗口中，我们可以看到如上输出，其输出的完整SQL如下：

SELECT TOP (9) 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Name] AS [Name], 
    [Extent1].[Sex] AS [Sex], 
    [Extent1].[StudentNum] AS [StudentNum]
    FROM ( SELECT [Extent1].[Id] AS [Id], [Extent1].[Name] AS [Name], [Extent1].[Sex] AS [Sex], [Extent1].[StudentNum] AS [StudentNum], row_number() OVER (ORDER BY [Extent1].[Id] ASC) AS [row_number]
        FROM [dbo].[Student] AS [Extent1]
    )  AS [Extent1]
    WHERE [Extent1].[row_number] > 0
    ORDER BY [Extent1].[Id] ASC

那么，我们怎样才能捕捉到这些SQL语句呢？

在MVC EF 默认的输出窗口中，这些SQL语句是不会输出的，我们需要增加一个‘捕捉器’来捕捉这些SQL语句。

综上所言，我们就基本了解了连接弹性和命令拦截的概念和基本意思。注：如有个人理解不对的地方，谨防误人子弟，希望大家在评论区指出，小弟拜谢

那么，我们需要写什么代码来达到连接弹性和命令拦截的功效呢？

如下<大家也可参考：Connection Resiliency and Command Interception with the Entity Framework in an ASP.NET MVC Application>

首先：如何启用弹性连接

在我们的EF项目中创建一个名称为：Configuration 的文件夹，在文件夹中首先添加一个数据库重连类：

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.SqlServer;
using System.Linq;
using System.Web;

namespace EF_Test.Configuration

{ public class StudentConfiguration : DbConfiguration { /// <summary> /// 需要引入命名空间：using System.Collections.Generic;和using System.Data.Entity.SqlServer; /// </summary> public StudentConfiguration() { //设置 SQL 数据库执行策略 默认重连四次 SetExecutionStrategy("System.Data.SqlClient", () => new SqlAzureExecutionStrategy()); } } }

上文中提到，如果不是SQL本身的异常，我们重新连接数据库，可能会得到我们想要的结果。例如查询数据时，突然断网，第一次查询失败，在数据库重连后，第二次查询成功，系统将查询结果反馈给客户，提高了客户体验。

但是，如果您写的SQL本身就是错误的，那无论重连几次数据都将是无用之功，这时，我们可以通过如下代码来捕获SQL执行异常：

在控制器代码中引用：using System.Data.Entity.Infrastructure;

            try
            {
                //有异常的SQL操作，SQL语句本身异常
            }
            catch (RetryLimitExceededException /* dex */)
            {
                //Log the error (uncomment dex variable name and add a line here to write a log.
                ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
            }

至此：数据库弹性连接的启用就完成了，下面我们继续命令拦截：

如何启用命令拦截：

首先在项目中创建文件夹：ILogger

1、创建日志接口和类：在日志记录文件夹中，创建一个名为ILogger.cs的类文件︰

    public interface ILogger
    {
        void Information(string message);
        void Information(string fmt, params object[] vars);
        void Information(Exception exception, string fmt, params object[] vars);

        void Warning(string message);
        void Warning(string fmt, params object[] vars);
        void Warning(Exception exception, string fmt, params object[] vars);

        void Error(string message);
        void Error(string fmt, params object[] vars);
        void Error(Exception exception, string fmt, params object[] vars);

        void TraceApi(string componentName, string method, TimeSpan timespan);
        void TraceApi(string componentName, string method, TimeSpan timespan, string properties);
        void TraceApi(string componentName, string method, TimeSpan timespan, string fmt, params object[] vars);

    }

2、在日志记录文件夹中，创建一个名为Logger.cs的类文件︰

    public class Logger : ILogger
    {

        public void Information(string message)
        {
            Trace.TraceInformation(message);
        }

        public void Information(string fmt, params object[] vars)
        {
            Trace.TraceInformation(fmt, vars);
        }

        public void Information(Exception exception, string fmt, params object[] vars)
        {
            Trace.TraceInformation(FormatExceptionMessage(exception, fmt, vars));
        }

        public void Warning(string message)
        {
            Trace.TraceWarning(message);
        }

        public void Warning(string fmt, params object[] vars)
        {
            Trace.TraceWarning(fmt, vars);
        }

        public void Warning(Exception exception, string fmt, params object[] vars)
        {
            Trace.TraceWarning(FormatExceptionMessage(exception, fmt, vars));
        }

        public void Error(string message)
        {
            Trace.TraceError(message);
        }

        public void Error(string fmt, params object[] vars)
        {
            Trace.TraceError(fmt, vars);
        }

        public void Error(Exception exception, string fmt, params object[] vars)
        {
            Trace.TraceError(FormatExceptionMessage(exception, fmt, vars));
        }

        public void TraceApi(string componentName, string method, TimeSpan timespan)
        {
            TraceApi(componentName, method, timespan, "");
        }

        public void TraceApi(string componentName, string method, TimeSpan timespan, string fmt, params object[] vars)
        {
            TraceApi(componentName, method, timespan, string.Format(fmt, vars));
        }
        public void TraceApi(string componentName, string method, TimeSpan timespan, string properties)
        {
            string message = String.Concat("Component:", componentName, ";Method:", method, ";Timespan:", timespan.ToString(), ";Properties:", properties);
            Trace.TraceInformation(message);
        }

        private static string FormatExceptionMessage(Exception exception, string fmt, object[] vars)
        {
            // Simple exception formatting: for a more comprehensive version see 
            // http://code.msdn.microsoft.com/windowsazure/Fix-It-app-for-Building-cdd80df4
            var sb = new StringBuilder();
            sb.Append(string.Format(fmt, vars));
            sb.Append(" Exception: ");
            sb.Append(exception.ToString());
            return sb.ToString();
        }
    }

3、在日志文件夹中创建拦截器类

using System;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure.Interception;
using System.Data.Entity.SqlServer;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Reflection;
using System.Linq;

namespace EF_Test.ILogger
{
    public class StudentInterceptorLogging : DbCommandInterceptor
    {
        private ILogger _logger = new Logger();
        private readonly Stopwatch _stopwatch = new Stopwatch();

        public override void ScalarExecuting(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
            base.ScalarExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }

        public override void ScalarExecuted(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                _logger.Error(interceptionContext.Exception, "Error executing command: {0}", command.CommandText);
            }
            else
            {
                _logger.TraceApi("SQL Database", "SchoolInterceptor.ScalarExecuted", _stopwatch.Elapsed, "Command: {0}: ", command.CommandText);
            }
            base.ScalarExecuted(command, interceptionContext);
        }

        public override void NonQueryExecuting(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
            base.NonQueryExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }

        public override void NonQueryExecuted(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                _logger.Error(interceptionContext.Exception, "Error executing command: {0}", command.CommandText);
            }
            else
            {
                _logger.TraceApi("SQL Database", "SchoolInterceptor.NonQueryExecuted", _stopwatch.Elapsed, "Command: {0}: ", command.CommandText);
            }
            base.NonQueryExecuted(command, interceptionContext);
        }

        public override void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
        {
            base.ReaderExecuting(command, interceptionContext);
            _stopwatch.Restart();
        }
        public override void ReaderExecuted(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
        {
            _stopwatch.Stop();
            if (interceptionContext.Exception != null)
            {
                _logger.Error(interceptionContext.Exception, "Error executing command: {0}", command.CommandText);
            }
            else
            {
                _logger.TraceApi("SQL Database", "SchoolInterceptor.ReaderExecuted", _stopwatch.Elapsed, "Command: {0}: ", command.CommandText);
            }
            base.ReaderExecuted(command, interceptionContext);
        }
    }
}

4、创建记录SQL错误的拦截器类

using System;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure.Interception;
using System.Data.Entity.SqlServer;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Reflection;
using System.Linq;

namespace EF_Test.ILogger
{
    public class StudentInterceptorTransientErrors : DbCommandInterceptor
    {
        private int _counter = 0;
        private ILogger _logger = new Logger();

        public override void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
        {
            bool throwTransientErrors = false;
            if (command.Parameters.Count > 0 && command.Parameters[0].Value.ToString() == "%Throw%")
            {
                throwTransientErrors = true;
                command.Parameters[0].Value = "%an%";
                command.Parameters[1].Value = "%an%";
            }

            if (throwTransientErrors && _counter < 4)
            {
                _logger.Information("Returning transient error for command: {0}", command.CommandText);
                _counter++;
                interceptionContext.Exception = CreateDummySqlException();
            }
        }

        private SqlException CreateDummySqlException()
        {
            // The instance of SQL Server you attempted to connect to does not support encryption
            var sqlErrorNumber = 20;

            var sqlErrorCtor = typeof(SqlError).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).Where(c => c.GetParameters().Count() == 7).Single();
            var sqlError = sqlErrorCtor.Invoke(new object[] { sqlErrorNumber, (byte)0, (byte)0, "", "", "", 1 });

            var errorCollection = Activator.CreateInstance(typeof(SqlErrorCollection), true);
            var addMethod = typeof(SqlErrorCollection).GetMethod("Add", BindingFlags.Instance | BindingFlags.NonPublic);
            addMethod.Invoke(errorCollection, new[] { sqlError });

            var sqlExceptionCtor = typeof(SqlException).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).Where(c => c.GetParameters().Count() == 4).Single();
            var sqlException = (SqlException)sqlExceptionCtor.Invoke(new object[] { "Dummy", errorCollection, null, Guid.NewGuid() });

            return sqlException;
        }
    }
}

至此，整个拦截器就建立完毕。

如果正确的使拦截器发挥作用呢？我们还需在全局应用文件中添加如下代码：

技术分享

代码如下：

        protected void Application_Start()
        {
           // Database.SetInitializer<StudentContext>(new DropCreateDatabaseIfModelChanges<StudentContext>());  

            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            //
            DbInterception.Add(new StudentInterceptorTransientErrors());
            DbInterception.Add(new StudentInterceptorLogging());
        }

当然，我们如果不想写在全局应用文件中，我们可以在数据库重连策略类中添加，如下：

        public StudentConfiguration()
        {
            //设置 SQL 数据库执行策略 默认重连四次
            SetExecutionStrategy("System.Data.SqlClient", () => new SqlAzureExecutionStrategy());
            //注册拦截器  using System.Data.Entity.Infrastructure.Interception;
            DbInterception.Add(new StudentInterceptorTransientErrors());
            DbInterception.Add(new StudentInterceptorLogging());
        }