Interpreting ASP.NET 5 & MVC6 Series (10): Controller and Action

We know that in MVC5 and previous versions, the life cycles of the two frameworks are different. In the new version of MVC6, MVC Controller/Web API Controller has been combined into one. In this chapter, we will mainly explain the definition and use of Controller and Action, as well as how to query the corresponding Controller and Action according to the route in the MVC framework.

Definition and use of Controller&Action

In the new version of the MVC6 framework, a Controller base class is still provided. In addition to Url, RouteData, HttpContext, Request, and Response, an IServiceProvider type Resovler property is also provided, which is a dependency injection container for obtaining instance objects of the specified type within the current request scope.

It follows the following rules:

Classes that inherit from Microsoft.AspNet.Mvc.Controller are definitely controllers, regardless of whether they have a Controller suffix or not.

If a custom XXXController that does not inherit Microsoft.AspNet.Mvc.Controller is to be used as an MVC Controller, it must reference the Microsoft.AspNet.Mvc related assemblies.

If you do not want a Controller class that meets the above conditions to be used as a Controller, you need to add the NonControllerAttribute attribute to the class.

Similarly, if you do not want a method in a Controller to be used as an Action, you need to add the NonActionAttribute attribute to the method.

There are also a few features to note:

Controller search mechanism

From the above sections, we know that MVC6 not only supports normal Controller (subclasses inherited from the Controller base class), but also supports POCO Controller. In this section, we will study the search principle mechanism of Controller.

First, to determine whether a class is a Controller, you must first determine how many assemblies define such a class. The IAssemblyProvider interface under the Microsoft.AspNet.Mvc namespace is used to cover all assemblies that may define Controllers. The default implementation of this interface is the DefaultAssemblyProvider class. In this class, the necessary condition is that the Controller that defines MVC must reference one or more of the following assemblies, as listed below:

 Microsoft.AspNet.Mvc
 Microsoft.AspNet.Mvc.Core
 Microsoft.AspNet.Mvc.ModelBinding
 Microsoft.AspNet.Mvc.Razor
 Microsoft.AspNet.Mvc.Razor.Host
 Microsoft.AspNet.Mvc.TagHelpers
 Microsoft.AspNet.Mvc.Xml
 Microsoft.AspNet.PageExecutionInstrumentation.Interfaces

That is to say, if you define a DLL class library that references Microsoft.AspNet.Mvc, the POCO Controllers in it will be considered as MVC Controllers. In other words, if the POCO Controller classes you define do not reference any of the above assemblies, then these Controller classes will not be considered as MVC Controllers.

Finding an assembly

There are currently two ways to customize the Controller's search mechanism. The first is to inherit IAssemblyProvider to implement the CandidateAssemblies method (or overload DefaultAssemblyProvider) to define your own logic. The interface definition is as follows:

 public   interface IAssemblyProvider
 {
    IEnumerable CandidateAssemblies { get; } }

Another way, which may be relatively simpler, is to use the extension method defined on IServicesCollection to define the assembly to be searched:

 services.AddMvc().WithControllersAsServices( new []
 {
    typeof(MyController).Assembly,
    typeof(ExternalPocoController).Assembly
 });

After using the above code, the system will switch DefaultAssemblyProvider to FixedSetAssemblyProvider to implement the above judgment mechanism, that is, searching in assemblies within a fixed range.

Filtering of assemblies

After determining the assembly, another question arises: how to determine whether an assembly references the assemblies listed in the above MVC prerequisites? The answer is that the GetReferencingLibraries method of the ILibraryManager interface instance in Microsoft.Framework.Runtime can find out how many assemblies reference one of the assemblies in the above list. For example, you can find out how many assemblies reference the Microsoft.AspNet.Mvc assembly based on the example below:

var col = this .Resolver.GetRequiredService(); var data = col.GetReferencingLibraries( "Microsoft.AspNet.Mvc" );

The usage code of this function in the default implementation class of DefaultAssemblyProvider is as follows:

protected virtual IEnumerable GetCandidateLibraries() { if (ReferenceAssemblies == null) { return Enumerable.Empty (); } // GetReferencingLibraries returns the transitive closure of referencing assemblies // for a given assembly. return ReferenceAssemblies.SelectMany(_libraryManager.GetReferencingLibraries) .Distinct() .Where(IsCandidateLibrary); }

Controller's judgment

After determining the assembly that meets the necessary conditions, you can traverse all types in the assembly and then determine whether the type is a Controller. In the new version of Controller judgment, this function is implemented by an IControllerTypeProvider interface, which provides a ControllerTypes read-only property for obtaining all defined Controllers. The interface definition is as follows:

 public   interface IControllerTypeProvider
 {
    IEnumerable ControllerTypes { get; } }

DefaultControllerTypeProvider is the default implementation of this interface. When querying for qualified Controllers, the default implementation class defines an IsController method to determine whether a type is a Controller. The specific logic is as follows:

protected internal virtual bool IsController([NotNull] TypeInfo typeInfo,
                                             [NotNull] ISet candidateAssemblies) { if (!typeInfo.IsClass) // The type must be a class{ return false; } if (typeInfo.IsAbstract) // The class must not be an abstract class{ return false; } // We only consider public top-level classes as controllers. IsPublic returns false for nested // classes, regardless of visibility modifiers if (!typeInfo.IsPublic) // The class must be a Public class (and not nested). Nested classes cannot be used as Controllers { return false; } if (typeInfo.ContainsGenericParameters) // The class cannot be a generic class{ return false; } if (!typeInfo.Name.EndsWith(ControllerTypeName, StringComparison.OrdinalIgnoreCase) && !DerivesFromController(typeInfo, candidateAssemblies)) // The class ends with Controller, or inherits from the Controller base class, or its parent class is also a Controller. { return false; } if (typeInfo.IsDefined(typeof(NonControllerAttribute))) // This class cannot set the NonControllerAttribute attribute { return false; } return true; }

You can also implement the IControllerTypeProvider interface to define your own Controller judgment logic. However, in addition to fixing certain assembly types, MVC also provides an extension method on IServicesCollection to limit some specific Controller types. The example is as follows:

services.AddMvc().WithControllersAsServices( new []
 {
 typeof(MyController),
        typeof(ExternalPocoController)
 });

After using the above code, the system will switch DefaultControllerTypeProvider to FixedSetControllerTypeProvider to implement the above judgment mechanism, that is, restrict certain specific classes to be used as Controllers, and other types cannot be used as Controllers.

Action search mechanism

The selection of Action is implemented by the default implementation class DefaultActionSelector of the IActionSelector interface. In the implemented SelectAsync method, the best matching Action is selected through the context and routing data. The schematic code is as follows:

 public Task SelectAsync([NotNull] RouteContext context) { // ... }

There is another place to determine whether a method is an action, that is the IActionModelBuilder interface, the default implementation of this interface is the DefaultActionModelBuilder class, the implementation method is as follows:

public IEnumerable BuildActionModels([NotNull] TypeInfo typeInfo, [NotNull] MethodInfo methodInfo) { if (!IsAction(typeInfo, methodInfo)) { return Enumerable.Empty(); } // ....Omit other code}

This implementation method uses an internal IsAction method to determine whether the method is a real Action method. The specific code is as follows:

 protected virtual bool IsAction([NotNull] TypeInfo typeInfo, [NotNull] MethodInfo methodInfo)
 {
 // The SpecialName bit is set to flag members that are treated in a special way by some compilers  
 // (such as property accessors and operator overloading methods).  
 if (methodInfo.IsSpecialName) // cannot be a special name (such as an overloaded operator or property accessor)  
 {
 return   false ;
 } 
 
 if (methodInfo.IsDefined(typeof(NonActionAttribute))) // Cannot declare NonActionAttribute attribute  
 {
 return   false ;
 } 
 
 // Overriden methods from Object class, eg Equals(Object), GetHashCode(), etc., are not valid.  
 if (methodInfo.GetBaseDefinition().DeclaringType == typeof(object)) //Cannot be an overloaded method, such as Equals and GetHashCode  
 {
 return   false ;
 } 
 
 // Dispose method implemented from IDisposable is not valid  
 if (IsIDisposableMethod(methodInfo, typeInfo)) // Cannot be a Dispose method  
 {
 return   false ;
 } 
 
 if (methodInfo.IsStatic) // cannot be a static method  
 {
 return   false ;
 } 
 
 if (methodInfo.IsAbstract) // cannot be an abstract method  
 {
 return   false ;
 } 
 
 if (methodInfo.IsConstructor) // cannot be a constructor  
 {
 return   false ;
 } 
 
 if (methodInfo.IsGenericMethod) // cannot be a generic method  
 {
 return   false ;
 } 
 
 return  
 methodInfo.IsPublic; // Must be a Public method  
 }

The above content is about the important code related to Controller and Action search. For detailed principles and steps, please refer to all source codes under the Microsoft.AspNet.Mvc.Core assembly.