ASP.NET MVC涉及到的5个同步与异步二

最新推荐文章于 2021-03-01 18:11:54 发布
最新推荐文章于 2021-03-01 18:11:54 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： asp.net mvc

Action方法的执行具有两种基本的形式，即同步执行和异步执行，而在ASP.NETMVC的整个体系中涉及到很多同步/异步的执行方式，虽然在前面相应的文章中已经对此作了相应的介绍，为了让读者对此有一个整体的了解，我们来做一个总结性的论述。[本文已经同步到《How ASP.NET MVC Works?》中]

目录 
一、MvcHandler的同步于异步 
二、Controller的同步与异步 
三、ActionInvoker的同步与异步 
四、ControllerDescriptor的同步与异步 
五、ActionDescriptor的同步与异步

一、MvcHandler的同步与异步

对于ASP.NET MVC应用来说，MvcHandler是最终用于处理请求的HttpHandler，它是通过UrlRoutingModule这个实现了URL路由的HttpModule被动态映射到相应的请求的。MvcHandler借助于ControllerFactory激活并执行目标Controller，并在执行结束后负责对激活的Controller进行释放，相关的内容请参与本书的第3章“Controller的激活”。如下面的代码片断所示，MvcHandler同时实现了IHttpHandler和IHttpAsyncHandler接口，所以它总是调用BeginProcessRequest/EndProcessRequest方法以异步的方式来处理请求。

   1: public class MvcHandler : IHttpAsyncHandler, IHttpHandler, ...
   2: {
   3:     //其他成员   
   4:     IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData);
   5:     void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result);
   6:     void IHttpHandler.ProcessRequest(HttpContext httpContext);
   7: }

二、Controller的同步与异步

Controller也具有同步与异步两个版本，它们分别实现了具有如下定义的两个接口IController和IAsyncController。当激活的Controller对象在MvcHandler的BeginProcessRequest方法中是按照这样的方式执行的：如果Controller的类型实现了IAsyncController接口，则调用BeginExecute/EndExecute方法以异步的方式执行Controller；否则Controller的执行通过调用Execute方法以同步方式执行。

   1: public interface IController
   2: {    
   3:     void Execute(RequestContext requestContext);
   4: }
   5: public interface IAsyncController : IController
   6: {    
   7:     IAsyncResult BeginExecute(RequestContext requestContext, AsyncCallback callback, object state);
   8:     void EndExecute(IAsyncResult asyncResult);
   9: }

默认情况下通过Visual Studio的向导创建的Controller类型是抽象类型Controller的子类。如下面的代码片断所示，Controller同时实现了IController和IAsyncController这两个接口，所以当MvcHandler进行请求处理时总是以异步的方式来执行Controller。

   1: public abstract class Controller : ControllerBase, IController, IAsyncController, ...
   2: {
   3:     //其他成员
   4:     protected virtual bool DisableAsyncSupport
   5:     {
   6:         get{return false;}
   7:     }
   8: }

但是Controller类型具有一个受保护的只读属性DisableAsyncSupport用于表示是否禁用对异步执行的支持。在默认情况下，该属性值为False，所以默认情况下是支持Controller的异步执行的。如果我们通过重写该属性将值设置为True，那么Controller将只能以同步的方式执行。具体的实现逻辑体现在如下的代码片断中：BeginExecute方法在DisableAsyncSupport属性为True的情况下通过调用Execute方法（该方法会调用一个受保护的虚方法ExecuteCore最终对Controller进行同步执行）；否则通过调用BeginExecuteCore/EndExecuteCore以异步方式执行Controller。

   1: public abstract class Controller: ...
   2: {
   3:     //其他成员
   4:     protected virtual IAsyncResult BeginExecute(RequestContext requestContext, 
   5:     AsyncCallback callback, object state)
   6:     {
   7:         if (this.DisableAsyncSupport)
   8:         {
   9:             //通过调用Execute方法同步执行Controller
  10:         }
  11:         else
  12:         {
  13:             //通过调用BeginExecuteCore/EndExecuteCore方法异步执行Controller
  14:         }
  15: }
  16:     protected override void ExecuteCore();
  17:     protected virtual IAsyncResult BeginExecuteCore(AsyncCallback callback, object state);
  18:     protected virtual void EndExecuteCore(IAsyncResult asyncResult);
  19: }

三、 ActionInvoker的同步与异步

包括Model绑定与验证的整个Action的执行通过一个名为ActionInvoker的组件来完成，而它同样具有同步和异步两个版本，分别实现了接口IActionInvoker和IAsyncActionInvoker。如下面的代码片断所示，这两个接口分别通过InvokeAction和BeginInvokeAction/EndInvokeAction方法以同步和异步的方式执行Action。抽象类Controller中具有一个ActionInvoker属性用于设置和返回用于执行自身Action的ActionInvoker对象，而该对象最终是通过受保护需方法CreateActionInvoker创建的。

   1: public interface IActionInvoker
   2: {
   3:     bool InvokeAction(ControllerContext controllerContext, string actionName);
   4: }
   5:  
   6: public interface IAsyncActionInvoker : IActionInvoker
   7: {
   8:     IAsyncResult BeginInvokeAction(ControllerContext controllerContext, string actionName, AsyncCallback callback, object state);
   9:     bool EndInvokeAction(IAsyncResult asyncResult);
  10: }
  11:  
  12: public abstract class Controller
  13: {   
  14:     //其它成员
  15:     public IActionInvoker ActionInvoker { get; set; }
  16:     protected virtual IActionInvoker CreateActionInvoker()
  17: }

ASP.NET MVC真正用于Action方法同步和异步执行的ActionInvoker分别是ControllerActionInvoker和AsyncControllerActionInvoker。如下面的代码片断所示，ControllerActionInvoker定义了一个受保护的方法GetControllerDescriptor用于根据指定的Controller上下文获取相应的ControllerDescriptor，它的子类AsyncControllerActionInvoker对这个方法进行了重写。

   1: public class ControllerActionInvoker : IActionInvoker
   2: {
   3:     //其它成员
   4:     protected virtual ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext);
   5: }
   6:  
   7: public class AsyncControllerActionInvoker : ControllerActionInvoker,IAsyncActionInvoker, IActionInvoker
   8: {
   9:     //其它成员
  10:    protected override ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext);
  11: }

我们所有要了解的是在默认情况下（没有对Controller类型的ActionInvoker属性进行显式设置）采用的ActionInvoker类型是哪个。ASP.NET MVC对Conroller采用的ActionInvoker类型的选择机制是这样的：

  • 通过当前的DependencyResolver以IAsyncActionInvoker接口去获取注册的ActionInvoker，如果返回对象不为Null，则将其作为默认的ActionInvoker。
  • ·通过当前的DependencyResolver以IActionInvoker接口去获取注册的ActionInvoker，如果返回对象不为Null，则将其作为默认的ActionInvoker。
  • 创建AsyncControllerActionInvoker对象作为默认的ActionInvoker。

在默认的情况下，当前的DependencyResolver直接通过对指定的类型进行反射来提供对应的实例对象，所以对于前面两个步骤返回的对象均为Null，所以默认创建出来的ActionInvoker类型为AsyncControllerActionInvoker。我们可以通过如下一个简单的实例来验证这一点。在通过Visual Studio的ASP.NET MVC项目模板创建的空Web应用中，我们创建了如下一个默认的HomeController，在Action方法Index中直接通过ContentResult将ActionInvoker属性的类型名称呈现出来。

   1: public class HomeController : Controller
   2: {  
   3:     public ActionResult Index()
   4:     {
   5:         return Content("默认ActionInvoker类型:" + this.ActionInvoker.GetType().FullName);
   6:     }
   7: }

当运行该Web应用时，会在浏览器上产生如下的输出结果，我们可以清楚地看到默认采用的ActionInvoker类型正是AsyncControllerActionInvoker。

   1: 默认ActionInvoker类型:System.Web.Mvc.Async.AsyncControllerActionInvoker

为了进一步验证基于DependencyResolver对ActionInvoker的提供机制，我们将《ASP.NET MVC Controller激活系统详解：IoC的应用[下篇]》创建的基于Ninject的自定义NinjectDependencyResolver应用在这里。如下面的代码片断所示，在初始化NinjectDependencyResolver的时候，我们将IActionInvoker和IAsyncActionInvoker影射到两个自定义ActionInvoker类型，即FooActionInvoker和FooAsyncActionInvoker，它们分别继承自ControllerActionInvoker和AsyncControllerActionInvoker。

   1: public class NinjectDependencyResolver : IDependencyResolver
   2: {
   3:     public IKernel Kernel { get; private set; }
   4:     public NinjectDependencyResolver()
   5:     {
   6:         this.Kernel = new StandardKernel();
   7:         AddBindings();
   8:     }
   9:     private void AddBindings()
  10:     {
  11:         this.Kernel.Bind<IActionInvoker>().To<FooActionInvoker>();
  12:         this.Kernel.Bind<IAsyncActionInvoker>().To<FooAsyncActionInvoker>();
  13:     }
  14:     public object GetService(Type serviceType)
  15:     {
  16:         return this.Kernel.TryGet(serviceType);
  17:     }
  18:     public IEnumerable<object> GetServices(Type serviceType)
  19:     {
  20:         return this.Kernel.GetAll(serviceType);
  21:     }
  22: }
  23: public class FooActionInvoker : ControllerActionInvoker
  24: {}
  25: public class FooAsyncActionInvoker : AsyncControllerActionInvoker
  26: {}

在Global.asax中对NinjectDependencyResolver进行注册后运行我们的程序，会在浏览器中得到如下的输出结果。IAsyncActionInvoker和FooAsyncActionInvoker进行了影射，NinjectDependencyResolver可以通过IAsyncActionInvoker提供一个FooAsyncActionInvoker实例。

   1: 默认ActionInvoker类型:Artech.Mvc.FooAsyncActionInvoker

现在我们对NinjectDependencyResolver的定义稍加修改，将针对IAsyncActionInvoker接口的类型影射删除，只保留针对IActionInvoker的映射。

   1: public class NinjectDependencyResolver : IDependencyResolver
   2: {
   3:     //其它成员
   4:     private void AddBindings()
   5:     {
   6:         this.Kernel.Bind<IActionInvoker>().To<FooActionInvoker>();
   7:         //this.Kernel.Bind<IAsyncActionInvoker>().To<FooAsyncActionInvoker>();
   8:     }
   9: }

再次运行我们的程序则会得到如下的输出结果。由于NinjectDependencyResolver只能通过IActionInvoker接口提供具体的ActionInvoker，所以最终被创建的是一个FooActionInvoker对象。这个实例演示告诉我们：当我们需要使用到自定义的ActionInvoker的时候，可以通过自定义DependencyResolver以IoC的方式提供具体的ActionInvoker实例。

   1: 默认ActionInvoker类型:Artech.Mvc.FooActionInvoker

 

关于ASP.NET MVC对请求的处理方式（同步或者异步）涉及到的五个组件，在《上篇》中我们谈了三个（MvcHandler、Controller和ActionInvoker），现在我们来谈余下的两个，即ControllerDescriptor和ActionDescriptor，这五个组件的执行并非孤立的，而是具有议定的关系。相信读者认真阅读了这两篇文章后，会对整个请求的处理方式有一个深刻的理解。[本文已经同步到《How ASP.NET MVC Works?》中]

目录 
一、MvcHandler的同步于异步 
二、Controller的同步与异步 
三、ActionInvoker的同步与异步 
四、ControllerDescriptor的同步与异步 
五、ActionDescriptor的同步与异步 
    1、实例演示：AsyncActionInvoker对ControllerDescriptor的创建 
    2、AsyncController、AsyncControllerActionInvoker与AsyncActionDescriptor 
    3、Action方法的执行

四、ControllerDescriptor的同步与异步

如果采用ControllerActionInvoker，Action总是以同步的方式来直接，但是当AsyncControllerActionInvoker作为Controller的ActionInvoker时，并不意味着总是以异步的方式来执行所有的Action。至于这两种类型的ActionInvoker具体采用对Action的怎样的执行方式，又涉及到两个描述对象，即用于描述Controller和Action的ControllerDescriptor和ActionDescriptor。

通过前面“Model的绑定”中对这两个对象进行过相应的介绍，我们知道在ASP.NET MVC应用编程接口中具有两个具体的ControllerDescriptor，即ReflectedControllerDescriptor和ReflectedAsyncControllerDescriptor，它们分别代表同步和异步版本的ControllerDescriptor。

   1: public class ReflectedControllerDescriptor : ControllerDescriptor
   2: {
   3:     //省略成员
   4: }
   5:  
   6: public class ReflectedAsyncControllerDescriptor : ControllerDescriptor
   7: {
   8:     //省略成员
   9: }

ReflectedControllerDescriptor和ReflectedAsyncControllerDescriptor并非对分别实现了IController和IAyncController接口的Controller的描述，而是对直接继承自抽象类Controller和AsyncController的Controller的描述。它们之间的区别在于创建者的不同，在默认情况下ReflectedControllerDescriptor和ReflectedAsyncControllerDescriptor分别是通过ControllerActionInvoker和AsyncControllerActionInvoker来创建的。ActionInvoker和ControllerDescriptor之间的关系可以通过如下图所示的UML来表示。

image

ActionInvoker与ControllerDescriptor之间的关系可以通过一个简单的实例来验证。在通过Visual Studio的ASP.NET MVC项目模板创建的空Web应用中，我们自定义了如下两个分别继承自ControllerActionInvoker和AsyncControllerActionInvoker的ActionInvoker类型。在这两个自定义ActionInvoker中，定义了公有的GetControllerDescriptor方法覆盖了基类的同名方法（受保护的虚方法），并直接直接调用基类的同名方法根据提供的Controller上下文的到相应的ControllerDescriptor对象。

   1: public class FooActionInvoker : ControllerActionInvoker
   2: { 
   3:     public new ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
   4:     {
   5:         return base.GetControllerDescriptor(controllerContext);
   6:     }
   7: }
   8:  
   9: public class BarActionInvoker : AsyncControllerActionInvoker
  10: {
  11:     public new ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
  12:     {
  13:         return base.GetControllerDescriptor(controllerContext);
  14:     }
  15: }

然后我们定义了两个Controller类型，它们均是抽象类型Controller的直接继承者。如下面的代码片断所示，这两Controller类（FooController和BarController）都重写了虚方法CreateActionInvoker，而返回的ActionInvoker类型分别是上面我们定义的FooActionInvoker和BarActionInvoker。在默认的Action方法Index中，我们利用当前的ActionInvoker得到用于描述本Controller的ControllerDescriptor对象，并将其类型呈现出来。

   1: public class FooController : Controller
   2: {
   3:     protected override IActionInvoker CreateActionInvoker()
   4:     {
   5:         return new FooActionInvoker();
   6:     }
   7:  
   8:     public void Index()
   9:     {
  10:         ControllerDescriptor controllerDescriptor = ((FooActionInvoker)this.ActionInvoker).GetControllerDescriptor(ControllerContext);
  11:         Response.Write(controllerDescriptor.GetType().FullName);
  12:     }
  13: }
  14:  
  15: public class BarController : Controller
  16: {
  17:     protected override IActionInvoker CreateActionInvoker()
  18:     {
  19:         return new BarActionInvoker();
  20:     }
  21:  
  22:     public void Index()
  23:     {
  24:         ControllerDescriptor controllerDescriptor = ((BarActionInvoker)this.ActionInvoker).GetControllerDescriptor(ControllerContext);
  25:         Response.Write(controllerDescriptor.GetType().FullName);
  26:     }
  27: }

现在我们运行我们的程序，并在浏览器中输入相应的地址对定义在FooController和BarController的默认Action方法Index发起访问，相应的ControllerDescriptor类型名称会以下图所示的形式呈现出来，它们的类型分别是ReflectedControllerDescriptor和ReflectedAsyncControllerDescriptor。

image

五、ActionDescriptor的执行

Controller包含一组用于描述Action方法的ActionDescriptor对象。由于Action方法可以采用同步和异步执行方法，异步Action对应的ActionDescriptor直接或者间接继承自抽象类AsyncActionDescriptor，后者是抽象类ActionDescriptor的子类。如下面的代码片断所示，同步和异步Action的执行分别通过调用Execute和BeginExecute/EndExecute方法来完成。值得一提的是，AsyncActionDescriptor重写了Execute方法并直接在此方法中抛出一个InvalidOperationException异常，也就是说AsyncActionDescriptor对象只能采用 异步执行方式。

   1: public abstract class ActionDescriptor : ICustomAttributeProvider
   2: {
   3:     //其他成员
   4:     public abstract object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters);
   5: }
   6:  
   7: public abstract class AsyncActionDescriptor : ActionDescriptor
   8: {
   9:     //其他成员
  10:     public abstract IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state);
  11:     public abstract object EndExecute(IAsyncResult asyncResult);
  12: }

通过前面“Model的绑定”我们知道，在ASP.NET MVC应用编程接口中采用ReflectedControllerDescriptor来描述同步Action。异步Action方法具有两种不同的定义方式：其一，通过两个匹配的方法XxxAsync/XxxCompleted定义；其二，通过返回类型为Task的方法来定义。这两种异步Action方法对应的AsyncActionDescriptor类型分别是ReflectedAsyncActionDescriptor和TaskAsyncActionDescriptor。

对于ReflectedControllerDescriptor来说，包含其中的ActionDescriptor类型均为ReflectedActionDescriptor。而ReflectedAsyncControllerDescriptor描述的Controller可以同时包含同步和异步的Action方法，ActionDescriptor的类型取决于Action方法定义的方式。ControllerDescriptor与ActionDescriptor之间的关系如下图所示的UML来表示。

image

实例演示：AsyncActionInvoker对ControllerDescriptor的创建

为了让读者对ActionInvoker对ControllerDescriptor的解析机制具有一个深刻的理解，同时也作为对该机制的验证，我们做一个简单的实例演示。通过前面的介绍我们知道在默认的情况下Controller采用AsyncControllerActionInvoker进行Action方法的执行，这个例子就来演示一下它生成的ControllerDescriptor是个怎样的对象。我们通过Visual Studio的ASP.NET MVC项目模板创建一个空Web应用，并创建一个默认的HomeController，然后对其进行如下的修改。

   1: public class HomeController : AsyncController
   2: {
   3:     public void Index()
   4:     {
   5:         MethodInfo method = typeof(AsyncControllerActionInvoker).GetMethod("GetControllerDescriptor", BindingFlags.Instance | BindingFlags.NonPublic);
   6:         ControllerDescriptor controllerDescriptor = (ControllerDescriptor)method.Invoke(this.ActionInvoker, new object[] { this.ControllerContext });
   7:         Response.Write(controllerDescriptor.GetType().FullName + "<br/>");
   8:         CheckAction(controllerDescriptor, "Foo");
   9:         CheckAction(controllerDescriptor, "Bar");
  10:         CheckAction(controllerDescriptor, "Baz");
  11:  
  12:     }
  13:      private void CheckAction(ControllerDescriptor controllerDescriptor,string actionName)
  14:     {
  15:         ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(this.ControllerContext, actionName);
  16:         Response.Write(string.Format("{0}: {1}<br/>",actionName,actionDescriptor.GetType().FullName));
  17:     }
  18:  
  19:     public void Foo() { }
  20:     public void BarAsync() { }
  21:     public void BarCompleted() { }
  22:     public Task<ActionResult> Baz()
  23:     {
  24:         throw new NotImplementedException();
  25:     }    
  26: }

我们首先将HomeController的基类从Controller改为AsyncController，并定义了Foo、BarAsync/BarCompleted和Baz四个方法，我们知道它们对应着Foo、Bar和Baz三个Action，其中Foo是同步Action，Bar和Baz分别是两种不同定义形式（XxxAsync/XxxCompleted和Task）的异步Action。

CheckAction用于根据指定的Action名称从ControllerDescriptor对象中获取用于表示对应Action的ActionDescriptor对象，最终将类型名称呈现出来。在Index方法中，我们通过反射的方式调用当前ActionInvoker（一个AsyncControllerActionInvoker对象）的受保护方法GetControllerDescriptor或者用于描述当前Controller（HomeController）的ControllerDescriptor的对象，并将类型名称呈现出来。最后通过调用CheckAction方法将包含在创建的ControllerDescriptor对象的三个ActionDescriptor类型呈现出来。

当我们运行该程序的时候，在浏览器中会产生如下的输出结果，从中可以看出ControllerDescriptor类型为ReflectedAsyncControllerDescriptor。同步方法Foo对象的ActionDescriptor是一个ReflectedActionDescriptor对象；以XxxAsync/XxxCompleted形式定义的异步方法Bar对应的ActionDescriptor是一个ReflectedAsyncActionDescriptor对象；而返回类型为Task的方法Baz对应的ActionDescriptor类型则是TaskAsyncActionDescriptor。

image

AsyncController、AsyncControllerActionInvoker与AsyncActionDescriptor

不论我们采用哪种形式的定义方式，异步Action方法都只能定义在继承自AsyncController的Controller类型中，否则将被认为是同步方法。此外，由于通过ControllerActionInvoker只能创建包含ReflectedActionDescriptor的ReflectedControllerDescriptor，如果我们在AsyncController中采用ControllerActionInvoker对象作为ActionInvoker，所有的Action方法也将被认为是同步的。

我们同样可以采用一个简单的实例演示来证实这一点。在通过Visual Studio的ASP.NET MVC项目模板创建的空Web应用中我们定义如下三个Controller（FooController、BarController和BazController）。我们重写了它们的CreateActionInvoker方法，返回的ActionInvoker类型（FooActionInvoker和BarActionInvoker）定义在上面，在这里我们将FooActionInvoker和BarActionInvoker看成是ControllerActionInvoker和AsyncControllerActionInvoker（默认使用的ActionInvoker）。

   1: public class FooController : AsyncController
   2: {
   3:     protected override IActionInvoker CreateActionInvoker()
   4:     {
   5:         return new BarActionInvoker();
   6:     }
   7:     public void Index()
   8:     {
   9:         BarActionInvoker actionInvoker = (BarActionInvoker)this.ActionInvoker;
  10:         Utility.DisplayActions(controllerContext=>actionInvoker.GetControllerDescriptor(ControllerContext),ControllerContext);
  11:     }
  12:  
  13:     public void DoSomethingAsync()
  14:     { }
  15:     public void DoSomethingCompleted()
  16:     { }
  17: }
  18:  
  19: public class BarController : Controller
  20: {
  21:     protected override IActionInvoker CreateActionInvoker()
  22:     {
  23:         return new BarActionInvoker();
  24:     }
  25:     public void Index()
  26:     {
  27:         BarActionInvoker actionInvoker = (BarActionInvoker)this.ActionInvoker;
  28:         Utility.DisplayActions(controllerContext => actionInvoker.GetControllerDescriptor(ControllerContext), ControllerContext);
  29:     }
  30:     public void DoSomethingAsync()
  31:     { }
  32:     public void DoSomethingCompleted()
  33:     { }
  34: }
  35:  
  36: public class BazController : Controller
  37: {
  38:     protected override IActionInvoker CreateActionInvoker()
  39:     {
  40:         return new FooActionInvoker();
  41:     }
  42:     public void Index()
  43:     {
  44:         FooActionInvoker actionInvoker = (FooActionInvoker)this.ActionInvoker;
  45:         Utility.DisplayActions(controllerContext => actionInvoker.GetControllerDescriptor(ControllerContext), ControllerContext);
  46:     }
  47:     public void DoSomethingAsync()
  48:     { }
  49:     public void DoSomethingCompleted()
  50:     { }
  51: }
  52:  
  53: public static class Utility
  54: {
  55:     public static void DisplayActions(Func<ControllerContext, ControllerDescriptor> controllerDescriptorAccessor, ControllerContext controllerContext)
  56:     { 
  57:         ControllerDescriptor controllerDescriptor = controllerDescriptorAccessor(controllerContext);
  58:         string[] actionNames = { "DoSomething", "DoSomethingAsync", "DoSomethingCompleted" };
  59:         Array.ForEach(actionNames, actionName =>
  60:             {
  61:                 ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext,actionName);
  62:                 if (null != actionDescriptor)
  63:                 {
  64:                     HttpContext.Current.Response.Write(string.Format("{0}: {1}<br/>", actionDescriptor.ActionName, actionDescriptor.GetType().Name));
  65:                 }
  66:             });
  67:     }
  68: }

我们在三个Controller中以异步Action的形式定义了两个方法DoSomethingAsync和DoSomethingCompleted。FooController继承自AsyncController，使用AsyncControllerActionInvoker作为其ActionInvoker，这是正常的定义；BarController虽然采用AsyncControllerActionInvoker，但是将抽象类Controller作为其基类；而BazController虽然继承自ActionInvoker，但ActionInvoker类型为ControllerActionInvoker。在默认的Action方法Index中，我们将通过DoSomethingAsync和DoSomethingCompleted方法定义的Action的名称和对应的ActionDescriptor类型输出来。

如果我们运行该程序，并在浏览器中输入相应的地址对定义在三个Controller的默认Action方法Index发起访问，会呈现出如下图所示的结果。我们可以清楚地看到，对于以XxxAsync/XxxCompleted形式定义的“异步”Action方法定义，只有针对AsyncController并且采用AsyncControllerActionInvoker的情况下才会被解析为一个异步Action。如果不满足这两个条件，它们会被视为两个普通的同步Action。

image

Action方法的执行

目标Action方法的最终执行由被激活的Controller的ActionInvoker决定，ActionInvoker最终通过调用对应的ActionDescriptor来执行被它描述的Action方法。如果采用ControllerActionInvoker，被它创建的ControllerDescriptor（ReflectedControllerDescriptor）只包含同步的ActionDescriptor（ReflectedActionDescriptor），所以Action方法总是以同步的方式被执行。

如果目标Controller是抽象类Controller的直接继承者，这也是通过Visual Studio的Controller创建向导的默认定义方式，ActionInvoker（ControllerActionInvoker/AsyncControllerActionInvoker）的选择只决定了创建的ControllerDescriptor的类型（ReflectedControllerDescriptor/ReflectedAsyncControllerDescriptor），ControllerDescriptor包含的所有ActionDescriptor依然是同步的（ReflectedActionDescriptor），所以Action方法也总是以同步的方式被执行。

以异步方式定义的Action方法（XxxAsync/XxxCompleted或采用Task返回类型）只有定义在继承自AsyncController的Controller类型中，并且采用AsyncControllerActionInvoker作为其ActionInvoker，最终才会创建AsyncActionDescriptor来描述该Action。也只有同时满足这两个条件，Action方法才能以异步的方式执行。


http://www.cnblogs.com/artech/archive/2012/06/21/sync-and-async-01.html


linybo2008
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解ASP.NET MVC下的异步Action的定义和执行原理
01-20
Visual Studio提供的Controller创建向导默认为我们创建一个继承自抽象类Controller的Controller类型，这样的Controller只能定义同步Action方法。如果我们需要定义异步Action方法，必须继承抽象类AsyncController。这篇问你讲述两种不同的异步Action的定义方法和底层执行原理。 一、基于线程池的请求处理 ASP.NET通过线程池的机制处理并发的HTTP请求。一个Web应用内部维护着一个线程池，当探测到抵达的针对本应用的请求时，会从池中获取一个空闲的线程来处理该请求。当处理完毕，线程不会被回收，而是重新释放到池中。线程池具有一个线
ASP.NET MVC的异步编程
爱.NET
10-12 202
ASP.NET MVC的异步编程 在上篇《ASP.NET中的异步编程》http://blog.csdn.net/zztfj/article/details/6837985的文章中，我们已经体会到异步编程给网站带来的高性能，高扩展性。现在ASP.NET已经发展到了MVC 3了，那么在MVC中该如何进行异步编程呢？放心，.NET FrameWork已经给我们提供了AsyncController（异...
Asp.net MVC-3-执行过程
aiqian8176的博客
07-11 136
本篇主要讲述MVC处理请求时创建Controller和执行Action的完整过程。 创建Controller 先查看MvcHandler中处理请求的方法BeginProcessRequest： protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpConte...
asp.net mvc 中使用async/await异步编程
weixin_30332241的博客
04-04 1445
已经介绍过async/await异步编程，但是按照一般的异步编程的步骤，在asp.net mvc页面中使用异步编程好像会经常报一个错误，错误信息如下：现在无法开始异步操作。异步操作只能在异步处理程序或模块中开始，或在页生存期中的特定事件过程中开始。如果此异常在执行 Page 时发生，请确保 Page 标记为 <%@ Page Async="true" %&g...
asp.net--mvc--异步编程
weixin_30892889的博客
08-31 95
Using Asynchronous Methods in ASP.NET MVC 4 asp.net mvc中的异步只能增加系统的性能，原来需要500个线程的，现在需要50个就够了，对一些常规的程序运行的时间上并没有减少，但是如何IO操作或者其他操作是非常耗时的，就可以使用异步来跳过，减少程序的反应时间 简单理解： 同步controller public ActionResult Ge...
Web API /ASP.NET MVC中的异步编程
04-05
在Web开发领域，ASP.NET MVC和Web API是微软提供的两个强大的框架，用于构建高效、可扩展的Web应用程序和服务。在处理高并发请求时，异步编程成为了一个关键特性，能够提高应用性能，避免阻塞线程，从而充分利用...
使用jTable，SignalR和ASP.NET MVC的实时异步网页
04-08
标题中的“使用jTable，SignalR和ASP.NET MVC的实时异步网页”指的是一个利用现代Web技术构建的实时交互式应用程序。在这个应用中，jTable是一个JavaScript库，用于在客户端展示和管理表格数据，SignalR是ASP.NET的...
锐浪asp.net MVC html5报表显示
09-15
在这个示例中，我们将探讨如何在C#环境下利用ASP.NET MVC框架来实现数据的主从显示。主从显示是一种常见的数据展示方式，它通常用于展示一对多关系的数据，如一个订单与多个订单详情，一个客户与多个订单等。这种...
ASP.Net中的async+await异步编程的实现
12-17
在ASP.NET中，异步编程是一种关键的技术，用于提高应用程序的响应性和性能。尤其是在Web开发中，当服务器需要处理耗时的操作（如网络I/O或数据库查询）时，使用异步编程可以避免阻塞线程，让服务器能够处理更多的...
如何开发ASP.NET MVC异步式（Async）处理应用
平湖秋月的专栏
10-07 2178
这个假期抽了点时间，在家准备一个项目的技术方案。特地对ASP.NET MVC框架下开发异步模式（ASync）应用做了一番研究。   这个项目的目标是开发出一个WEB应用，该应用的并发业务请求量非常大，而业务的处理，则大部分由第三方系统提供的Web Service完成。   为了提高系统的吞吐量，采用异步式模型来调用第三方的Web Service是最好的选择。在此，先简单介绍一下异步式模型的
CSRF in asp.net mvc and ap.net core
weixin_30632089的博客
09-16 227
如果在方法上添加了[ValidateAntiForgeryToken]，没处理好 请求没有带参数 2019-09-17 14:02:45,142 ERROR [36]: System.Web.Mvc.HttpAntiForgeryException (0x80004005): The required anti-forgery form field "__RequestVerific...
log4net在C# web开发中的使用（MVC）
柠檬凉瑾年的博客
07-11 640
（1）新建一个mvc项目（2）添加对log4Net.dll的引用（3）在configSections中添加如下配置节点：<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/> （4）紧靠configSections添加如下配置信息<log4net> <root> <lev
Aspnet MVC 异步调用
ai0168的博客
05-28 277
一个简图来描述下Aspnet MVC下的异步调用 { request } / \/ -------ISS------- > work thread | \ | \ route - aysn controller | \ | \ [invoke] clr thread pool ...
mutation和action 区别
热门推荐
coolsheep_的博客
03-01 1万+
mutations在请求数据的时候是同步的;而actions是异步的； action的功能和mutation是类似的，都是去变更store里的state，不过action和mutation有两点不同： action主要处理的是异步的操作，mutation必须同步执行，而action就不受这样的限制，也就是说action中我们既可以处理同步，也可以处理异步的操作 action改变状态，最后是通过提交mutation ———————————————— mutation this.$store.c
ASP.NET MVC 相同Controller的解决办法
weixin_34104341的博客
08-11 203
  今天做的MVC程序里，有两个WebSite,有两个不同命名空间的HomeController,网站启动时，/Home/Index, 提示有两个HomeController. 系统不知道使用哪一个 register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' para...
深入理解ASP.NET MVC（9）
weixin_30478923的博客
01-07 172
系列目录 异步处理请求的意义 大伙儿都知道，ASP.NET通过线程池处理请求，对于每个请求从线程池中请求一个可用的线程来处理请求，当请求处理完毕之后，线程资源将被归还到线程池。然而，线程池中的线程是互斥资源，当网站在同一时刻的请求量达到一定数量的话，必然会导致这种资源不够耗尽，新来的请求只能等待有新的线程归还才能被处理。当然这不是最糟糕的，通常每个请求只需要很短的时间就可以了，新的请求不会等待...
springMVC 一个Controller处理所有用户请求的并发问题
dev_hui 的博客
12-10 3527
SpringMVC一个Controller处理所有用户请求的并发问题 有状态和无状态的对象基本概念：  有状态对象(Stateful Bean)，就是有实例变量的对象 ，可以保存数据，是非线程安全的。一般是prototype scope。 无状态对象(Stateless Bean)，就是没有实例变量的对象，不能保存数据，是不变类，是线程安全的。一般是singleton scope。 如Stru...
MVC实现有关时间的进度条，使用jQuery ui的progressbar
Warren专栏
08-26 2939
在电商网站中，有时候通过进度条来直观地显示用户是否到期以及用户当前的状态。   设计这样的一个Model。 public class User { public int Id { get; set; } public string Name { get; set; } public int CoopTime {

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值