Shulou(Shulou.com)06/02 Report--

ASP.NET MVC involves five synchronous and asynchronous respectively, I believe that many inexperienced people do not know what to do, so this paper summarizes the causes of the problem and solutions, through this article I hope you can solve this problem.

The execution of Action method has two basic forms, synchronous execution and asynchronous execution, and there are many synchronous / asynchronous execution modes involved in the whole system of ASP.NETMVC, although this has been introduced in the previous corresponding article, in order to let readers have an overall understanding, let's make a summary discussion.

I. synchronization and asynchronism of MvcHandler

For ASP.NET MVC applications, MvcHandler is the HttpHandler that is ultimately used to process requests, and it is dynamically mapped to the corresponding requests through UrlRoutingModule, the HttpModule that implements URL routing. MvcHandler activates and executes the target Controller with the help of ControllerFactory, and is responsible for releasing the activated Controller after execution. For related content, please participate in Chapter 3 of this book, "Activation of Controller". As the following code snippet shows, MvcHandler implements both the IHttpHandler and IHttpAsyncHandler interfaces, so it always calls the BeginProcessRequest/EndProcessRequest method to handle requests asynchronously.

Public class MvcHandler: IHttpAsyncHandler, IHttpHandler,... {/ / other members IAsyncResult IHttpAsyncHandler.BeginProcessRequest (HttpContext context, AsyncCallback cb, object extraData); void IHttpAsyncHandler.EndProcessRequest (IAsyncResult result); void IHttpHandler.ProcessRequest (HttpContext httpContext);}

Synchronization and asynchronism of Controller

Controller is also available in synchronous and asynchronous versions, which implement two interfaces, IController and IAsyncController, which are defined below.

Public interface IController {void Execute (RequestContext requestContext);} public interface IAsyncController: IController {IAsyncResult BeginExecute (RequestContext requestContext, AsyncCallback callback, object state); void EndExecute (IAsyncResult asyncResult);}

By default, the Controller type created through Visual Studio's wizard is a subclass of the abstract type Controller. As shown in the following code snippet, Controller implements both IController and IAsyncController interfaces, so Controller is always executed asynchronously when MvcHandler does request processing.

Public abstract class Controller: ControllerBase, IController, IAsyncController,... {/ / other members protected virtual bool DisableAsyncSupport {get {return false;}}

The specific implementation logic is reflected in the following code snippet: the BeginExecute method calls the Execute method when the DisableAsyncSupport property is True (which calls a protected virtual method ExecuteCore to execute the Controller synchronously); otherwise, the Controller is executed asynchronously by calling BeginExecuteCore/EndExecuteCore.

Public abstract class Controller:. {/ / other members protected virtual IAsyncResult BeginExecute (RequestContext requestContext, AsyncCallback callback) Object state) {if (this.DisableAsyncSupport) {/ / synchronously execute Controller} else {/ / asynchronously execute Controller}} protected override void ExecuteCore () by calling the BeginExecuteCore/EndExecuteCore method Protected virtual IAsyncResult BeginExecuteCore (AsyncCallback callback, object state); protected virtual void EndExecuteCore (IAsyncResult asyncResult);}

Synchronization and asynchronism of ActionInvoker

The entire Action, which includes Model binding and validation, is executed through a component called ActionInvoker, which is also available in synchronous and asynchronous versions, implementing interfaces IActionInvoker and IAsyncActionInvoker, respectively. As shown in the following code snippet, these two interfaces execute Action synchronously and asynchronously through the InvokeAction and BeginInvokeAction/EndInvokeAction methods, respectively. The abstract class Controller has an ActionInvoker property that sets and returns the ActionInvoker object used to execute its own Action, which is ultimately created by the protected required method CreateActionInvoker.

Public interface IActionInvoker {bool InvokeAction (ControllerContext controllerContext, string actionName);} public interface IAsyncActionInvoker: IActionInvoker {IAsyncResult BeginInvokeAction (ControllerContext controllerContext, string actionName, AsyncCallback callback, object state); bool EndInvokeAction (IAsyncResult asyncResult);} public abstract class Controller {/ / other members public IActionInvoker ActionInvoker {get; set;} protected virtual IActionInvoker CreateActionInvoker ()}

The ActionInvoker that ASP.NET MVC really uses for synchronous and asynchronous execution of Action methods are ControllerActionInvoker and AsyncControllerActionInvoker, respectively. As shown in the following code snippet, ControllerActionInvoker defines a protected method, GetControllerDescriptor, to get the corresponding ControllerDescriptor based on the specified Controller context, which is overridden by its subclass AsyncControllerActionInvoker.

Public class ControllerActionInvoker: IActionInvoker {/ / other member protected virtual ControllerDescriptor GetControllerDescriptor (ControllerContext controllerContext);} public class AsyncControllerActionInvoker: ControllerActionInvoker,IAsyncActionInvoker, IActionInvoker {/ / other member protected override ControllerDescriptor GetControllerDescriptor (ControllerContext controllerContext)

All we need to know is which ActionInvoker type is used by default (there is no explicit setting for the ActionInvoker property of the ActionInvoker type). ASP.NET MVC's selection mechanism for the ActionInvoker type adopted by Conroller is as follows:

The registered ActionInvoker is obtained through the IAsyncActionInvoker interface through the current DependencyResolver. If the returned object is not Null, it will be used as the default ActionInvoker.

The registered ActionInvoker is obtained through the IActionInvoker interface through the current DependencyResolver. If the returned object is not Null, it will be used as the default ActionInvoker.

Create an AsyncControllerActionInvoker object as the default ActionInvoker.

By default, the current DependencyResolver provides the corresponding instance object directly by reflecting the specified type, so the object returned in the first two steps is Null, so the default created ActionInvoker type is AsyncControllerActionInvoker. We can verify this through the following simple example. In the empty Web application created through Visual Studio's ASP.NET MVC project template, we created the following default HomeController, which renders the type name of the ActionInvoker property directly through ContentResult in the Action method Index.

Public class HomeController: Controller {public ActionResult Index () {return Content ("default ActionInvoker type:" + this.ActionInvoker.GetType () .FullName);}}

When running the Web application, the following output is produced on the browser, and we can clearly see that the default ActionInvoker type is AsyncControllerActionInvoker.

Default ActionInvoker type: System.Web.Mvc.Async.AsyncControllerActionInvoker

In order to further verify the mechanism of providing ActionInvoker based on DependencyResolver, we put the Ninject-based custom NinjectDependencyResolver application created by "detailed introduction of ASP.NET MVC Controller Activation system: application of IoC" here. As the following code snippet shows, when initializing NinjectDependencyResolver, we map IActionInvoker and IAsyncActionInvoker to two custom ActionInvoker types, FooActionInvoker and FooAsyncActionInvoker, which inherit from ControllerActionInvoker and AsyncControllerActionInvoker, respectively.

Public class NinjectDependencyResolver: IDependencyResolver {public IKernel Kernel {get; private set;} public NinjectDependencyResolver () {this.Kernel = new StandardKernel (); AddBindings ();} private void AddBindings () {this.Kernel.Bind () .To (); this.Kernel.Bind () .To () } public object GetService (Type serviceType) {return this.Kernel.TryGet (serviceType);} public IEnumerable GetServices (Type serviceType) {return this.Kernel.GetAll (serviceType);}} public class FooActionInvoker: ControllerActionInvoker {} public class FooAsyncActionInvoker: AsyncControllerActionInvoker {}

Run our program after registering NinjectDependencyResolver in Global.asax, and you will get the following output in the browser.

Default ActionInvoker type: Artech.Mvc.FooAsyncActionInvoker

Now we modify the definition of NinjectDependencyResolver slightly to remove the type mapping for the IAsyncActionInvoker interface, leaving only the mapping for IActionInvoker.

Public class NinjectDependencyResolver: IDependencyResolver {/ / other members private void AddBindings () {this.Kernel.Bind () .To (); / / this.Kernel.Bind () .To ();}}

Run our program again and you will get the following output. Since NinjectDependencyResolver can only provide a specific ActionInvoker through the IActionInvoker interface, a FooActionInvoker object is eventually created. This example demonstrates that when we need to use a custom ActionInvoker, we can provide a specific ActionInvoker instance in the form of IoC through a custom DependencyResolver.

Default ActionInvoker type: Artech.Mvc.FooActionInvoker

Synchronization and asynchronism of ControllerDescriptor

If you use ControllerActionInvoker,Action, it is always synchronous, but when AsyncControllerActionInvoker is the ActionInvoker of Controller, it does not mean that all Action is always executed asynchronously. As for the specific implementation of these two types of ActionInvoker to Action, it involves two description objects, namely, ControllerDescriptor and ActionDescriptor, which are used to describe Controller and Action.

Through the previous introduction to these two objects in "binding of Model", we know that there are two specific ControllerDescriptor in the ASP.NET MVC API, ReflectedControllerDescriptor and ReflectedAsyncControllerDescriptor, which represent synchronous and asynchronous versions of ControllerDescriptor, respectively.

Public class ReflectedControllerDescriptor: ControllerDescriptor {/ / omitted member} public class ReflectedAsyncControllerDescriptor: ControllerDescriptor {/ / omitted member}

ReflectedControllerDescriptor and ReflectedAsyncControllerDescriptor are not descriptions of Controller that implements IController and IAyncController interfaces respectively, but descriptions of Controller that inherit directly from abstract classes Controller and AsyncController. The difference between them lies in the creator. By default, ReflectedControllerDescriptor and ReflectedAsyncControllerDescriptor are created through ControllerActionInvoker and AsyncControllerActionInvoker, respectively. The relationship between ActionInvoker and ControllerDescriptor can be represented by the UML shown in the following figure.

The relationship between ActionInvoker and ControllerDescriptor can be verified by a simple example. In the empty Web application created through Visual Studio's ASP.NET MVC project template, we customized the following two ActionInvoker types that inherit from ControllerActionInvoker and AsyncControllerActionInvoker, respectively. In these two custom ActionInvoker, the public GetControllerDescriptor method is defined to override the base class's method of the same name (the protected virtual method), and directly calls the base class's method of the same name to the corresponding ControllerDescriptor object according to the provided Controller context.

Public class FooActionInvoker: ControllerActionInvoker {public new ControllerDescriptor GetControllerDescriptor (ControllerContext controllerContext) {return base.GetControllerDescriptor (controllerContext);}} public class BarActionInvoker: AsyncControllerActionInvoker {public new ControllerDescriptor GetControllerDescriptor (ControllerContext controllerContext) {return base.GetControllerDescriptor (controllerContext);}}

Then we define two Controller types, both of which are direct inheritors of the abstract type Controller. In the default Action method Index, we use the current ActionInvoker to get the ControllerDescriptor object that describes this Controller and render its type.

Public class FooController: Controller {protected override IActionInvoker CreateActionInvoker () {return new FooActionInvoker ();} public void Index () {ControllerDescriptor controllerDescriptor = ((FooActionInvoker) this.ActionInvoker) .GetControllerDescriptor (ControllerContext); Response.Write (controllerDescriptor.GetType () .FullName);}} public class BarController: Controller {protected override IActionInvoker CreateActionInvoker () {return new BarActionInvoker ()

Now let's run our program and enter the corresponding address in the browser to initiate access to the default Action method Index defined in FooController and BarController, and the corresponding ControllerDescriptor type names will be rendered as shown in the following figure, with the types ReflectedControllerDescriptor and ReflectedAsyncControllerDescriptor, respectively.

V. implementation of ActionDescriptor

Controller contains a set of ActionDescriptor objects that describe Action methods. Because Action methods can be executed synchronously and asynchronously, the ActionDescriptor corresponding to asynchronous Action inherits directly or indirectly from the abstract class AsyncActionDescriptor, which is a subclass of the abstract class ActionDescriptor. As shown in the following code snippet, synchronous and asynchronous Action execution is accomplished by calling the Execute and BeginExecute/EndExecute methods, respectively. It is worth mentioning that AsyncActionDescriptor overrides the Execute method and throws an InvalidOperationException exception directly in this method, which means that AsyncActionDescriptor objects can only be executed asynchronously.

Public abstract class ActionDescriptor: ICustomAttributeProvider {/ / other members public abstract object Execute (ControllerContext controllerContext, IDictionary parameters);} public abstract class AsyncActionDescriptor: ActionDescriptor {/ / other members public abstract IAsyncResult BeginExecute (ControllerContext controllerContext, IDictionary parameters, AsyncCallback callback, object state); public abstract object EndExecute (IAsyncResult asyncResult);}

We know from the previous "binding of Model" that ReflectedControllerDescriptor is used to describe synchronous Action in the ASP.NET MVC API. Asynchronous Action methods can be defined in two different ways: one is defined by two matching methods XxxAsync/XxxCompleted, and the other is defined by methods with a return type of Task. The AsyncActionDescriptor types corresponding to these two asynchronous Action methods are ReflectedAsyncActionDescriptor and TaskAsyncActionDescriptor, respectively.

For ReflectedControllerDescriptor, the included ActionDescriptor type is ReflectedActionDescriptor. The relationship between ControllerDescriptor and ActionDescriptor is represented by the UML shown in the following figure.

Example demonstration: AsyncActionInvoker's creation of ControllerDescriptor

In order to let readers have a deep understanding of the parsing mechanism of ActionInvoker to ControllerDescriptor, and as a verification of this mechanism, we do a simple example demonstration. Through the previous introduction, we know that Controller uses AsyncControllerActionInvoker to execute the Action method by default, and this example demonstrates what kind of object it generates ControllerDescriptor.

Public class HomeController: AsyncController {public void Index () {MethodInfo method = typeof (AsyncControllerActionInvoker) .GetMethod ("GetControllerDescriptor", BindingFlags.Instance | BindingFlags.NonPublic); ControllerDescriptor controllerDescriptor = (ControllerDescriptor) method.Invoke (this.ActionInvoker, new object [] {this.ControllerContext}); Response.Write (controllerDescriptor.GetType (). FullName + "); CheckAction (controllerDescriptor," Foo "); CheckAction (controllerDescriptor," Bar ") CheckAction (controllerDescriptor, "Baz");} private void CheckAction (ControllerDescriptor controllerDescriptor,string actionName) {ActionDescriptor actionDescriptor = controllerDescriptor.FindAction (this.ControllerContext, actionName); Response.Write (string.Format ("{0}: {1}", actionName,actionDescriptor.GetType () .FullName)) } public void Foo () {} public void BarAsync () {} public void BarCompleted () {} public Task Baz () {throw new NotImplementedException ();}

We first change the base class of HomeController from Controller to AsyncController, and define four methods: Foo, BarAsync/BarCompleted and Baz. We know that they correspond to three Action of Foo, Bar and Baz, where Foo is synchronous Action,Bar and Baz is asynchronous Action with two different definitions (XxxAsync/XxxCompleted and Task).

In the Index method, we call the protected method GetControllerDescriptor of the current ActionInvoker (an AsyncControllerActionInvoker object) or the object used to describe the current Controller (HomeController) through reflection, and render the type name.

When we run the program, we will produce the following output in the browser, from which we can see that the ControllerDescriptor type is ReflectedAsyncControllerDescriptor. The ActionDescriptor of the synchronous method Foo object is a ReflectedActionDescriptor object; the ActionDescriptor of the asynchronous method Bar defined in the form of XxxAsync/XxxCompleted is a ReflectedAsyncActionDescriptor object; and the ActionDescriptor type of the method Baz with the return type Task is TaskAsyncActionDescriptor.

AsyncController, AsyncControllerActionInvoker and AsyncActionDescriptor

No matter which form of definition we use, asynchronous Action methods can only be defined in Controller types that inherit from AsyncController, otherwise they will be considered synchronous methods. In addition, because only ReflectedControllerDescriptor containing ReflectedActionDescriptor can be created through ControllerActionInvoker, if we use the ControllerActionInvoker object as the ActionInvoker in AsyncController, all Action methods will also be considered synchronous.

We can also use a simple example to prove this. In the empty Web application created through Visual Studio's ASP.NET MVC project template, we define the following three Controller (FooController, BarController, and BazController). We rewrite their CreateActionInvoker methods, and the returned ActionInvoker types (FooActionInvoker and BarActionInvoker) are defined above, where we think of FooActionInvoker and BarActionInvoker as ControllerActionInvoker and AsyncControllerActionInvoker (the default ActionInvoker).

Public class FooController: AsyncController {protected override IActionInvoker CreateActionInvoker () {return new BarActionInvoker ();} public void Index () {BarActionInvoker actionInvoker = (BarActionInvoker) this.ActionInvoker; Utility.DisplayActions (controllerContext= > actionInvoker.GetControllerDescriptor (ControllerContext), ControllerContext) } public void DoSomethingAsync () {} public void DoSomethingCompleted () {} public class BarController: Controller {protected override IActionInvoker CreateActionInvoker () {return new BarActionInvoker ();} public void Index () {BarActionInvoker actionInvoker = (BarActionInvoker) this.ActionInvoker; Utility.DisplayActions (controllerContext = > actionInvoker.GetControllerDescriptor (ControllerContext), ControllerContext) } public void DoSomethingAsync () {} public void DoSomethingCompleted () {} public class BazController: Controller {protected override IActionInvoker CreateActionInvoker () {return new FooActionInvoker ();} public void Index () {FooActionInvoker actionInvoker = (FooActionInvoker) this.ActionInvoker; Utility.DisplayActions (controllerContext = > actionInvoker.GetControllerDescriptor (ControllerContext), ControllerContext) } public void DoSomethingAsync () {} public void DoSomethingCompleted () {}} public static class Utility {public static void DisplayActions (Func controllerDescriptorAccessor, ControllerContext controllerContext) {ControllerDescriptor controllerDescriptor = controllerDescriptorAccessor (controllerContext); string [] actionNames = {"DoSomething", "DoSomethingAsync", "DoSomethingCompleted"} Array.ForEach (actionNames, actionName = > {ActionDescriptor actionDescriptor = controllerDescriptor.FindAction (controllerContext,actionName); if (null! = actionDescriptor) {HttpContext.Current.Response.Write (string.Format ("{0}: {1}", actionDescriptor.ActionName, actionDescriptor.GetType () .Name)) });}}

We define two methods, DoSomethingAsync and DoSomethingCompleted, in the form of asynchronous Action in the three Controller. FooController inherits from AsyncController and uses AsyncControllerActionInvoker as its ActionInvoker, which is a normal definition; BarController takes AsyncControllerActionInvoker, but has the abstract class Controller as its base class; and BazController inherits from ActionInvoker, but the ActionInvoker type is ControllerActionInvoker. In the default Action method Index, we output the name of the Action defined by the DoSomethingAsync and DoSomethingCompleted methods and the corresponding ActionDescriptor type.

If we run the program and enter the appropriate address in the browser to initiate access to the default Action method Index defined in the three Controller, we will present the result shown in the following figure. We can clearly see that an "asynchronous" Action method definition defined in the form of XxxAsync/XxxCompleted is resolved to an asynchronous Action only if it is for AsyncController and uses AsyncControllerActionInvoker. If these two conditions are not met, they are treated as two normal synchronous Action.

Execution of Action method

The final execution of the target Action method is determined by the ActionInvoker of the activated Controller, and the ActionInvoker finally executes the Action method described by it by calling the corresponding ActionDescriptor. If you use ControllerActionInvoker, the ControllerDescriptor (ReflectedControllerDescriptor) created by it contains only synchronous ActionDescriptor (ReflectedActionDescriptor), so the Action method is always executed synchronously.

If the target Controller is the direct successor of the abstract class Controller, which is the default definition of the Controller creation wizard through Visual Studio, the choice of ActionInvoker (ControllerActionInvoker/AsyncControllerActionInvoker) only determines the type of ControllerDescriptor created (ReflectedControllerDescriptor/ReflectedAsyncControllerDescriptor), and all ActionDescriptor contained in ControllerDescriptor is still ReflectedActionDescriptor, so the Action method is always executed synchronously.

An Action method defined asynchronously (XxxAsync/XxxCompleted or using a Task return type) will eventually create an AsyncActionDescriptor to describe the Action only if it is defined in a Controller type that inherits from AsyncController and takes AsyncControllerActionInvoker as its ActionInvoker. Only if both of these conditions are met can the Action method be executed asynchronously.

After reading the above, have you mastered the five synchronous and asynchronous methods involved in ASP.NET MVC? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.