Interpreting ASP.NET 5 & MVC6 Series (15): MvcOptions Configuration

Program model handling IApplicationModelConvention

On the instance object of MvcOptions, there is an ApplicationModelConventions property (type: List ), the interface collection of the property IApplicationModelConvention type is used to process the application model ApplicationModel. This collection is called when the MVC program starts, so before calling it, we can modify or update it. For example, we can define authorization for all Controllers and Actions in the database, read the data authorization information when the program starts, and then process the application model ApplicationModel. The example is as follows:

 public   class PermissionCheckApplicationModelConvention : IApplicationModelConvention
 {
 public   void Apply(ApplicationModel application)
 {
        foreach (var controllerModel in application.Controllers)
 {
            var controllerType = controllerModel.ControllerType;
            var controllerName = controllerModel.ControllerName; 
 
            controllerModel.Actions.ToList().ForEach(actionModel =>
 {
                var actionName = actionModel.ActionName;
                var parameters = actionModel.Parameters; 
 
 //According to the judgment conditions, modify the actionModel  
 }); 
 
 //According to the judgment conditions, modify the ControllerModel  
 }
 }
 }

View Engine ManagementViewEngines

In the instance object of MvcOptions, there is a ViewEngines property that is used to save the system's view engine collection so that we can implement our own custom view engine. For example, in the "Custom View View File Search Logic" chapter, we used this feature to implement our own custom view engine. The example is as follows:

 services.AddMvc().Configure(options => { options.ViewEngines.Clear(); options.ViewEngines.Add(typeof(ThemeViewEngine)); });

InputFormater/OutputFormater in Web API

enter

The processing of input parameters of Web API and current MVC currently supports JSON and XML formats. The specific processing classes are as follows:

 JsonInputFormatter
 XmlDataContractSerializerInputFormatter

Output

In Web API, there are four default output formatters:

 HttpNoContentOutputFormatter
 StringOutputFormatter
 JsonOutputFormatter
 XmlDataContractSerializerOutputFormatter

The above four types are automatically judged and output according to different situations in the system. The specific judgment rules are as follows:

If the action is similar to the following, use HttpNoContentOutputFormatter to return 204, which means NoContent.

public Task DoSomethingAsync()
 {
 // Return Task  
 } 
 
 public   void DoSomething()
 {
 // Void method  
 } 
 
 public string GetString()
 {
 return   null ; // returns null  
 } 
 
 public List GetData() { return   null ; // returns null }

If the following method also returns a string, only the Action whose return type is string will use StringOutputFormatter to return the string; if the Action whose return type is object, use JsonOutputFormatter to return the string data of JSON type.

 public object GetData()
 {
 return "The Data" ; // Return JSON  
 } 
 
 public string GetString()
 {
 return "The Data" ; // Return a string  
 }

If neither of the above two types of actions is used, JsonOutputFormatter is used by default to return JSON data. If the JsonOutputFormatter formatter is deleted through the following statement, XmlDataContractSerializerOutputFormatter will be used to return XML data.

 services.Configure(options => options.OutputFormatters.RemoveAll(formatter => formatter.Instance is JsonOutputFormatter) )

Of course, you can also use ProducesAttribute to explicitly declare the use of the JsonOutputFormatter formatter, as shown below.

 public   class Product2Controller : Controller
 {
    [Produces( "application/json" )]
 //[Produces("application/xml")]  
 public ProductDetail( int id)
 {
 return   new Product() { ProductId = id, ProductName = "Product Name" };
 }
 }

Alternatively, you can use the ProducesAttribute on the base Controller class, as shown below:

 [Produces( "application/json" )]
 public   class JsonController : Controller { } 
 
 public   class HomeController : JsonController
 {
 public List GetMeData() { return GetDataFromSource(); } }

Of course, you can also declare the ProducesAttribute in the global scope, as shown below:

 services.Configure(options => options.Filters.Add(newProducesAttribute( "application/json" )) );

Output Cache and Profile

In MVC6, the OutputCache feature is supported by the ResponseCacheAttribute class, as shown below:

 [ResponseCache(Duration = 100 )]
 public IActionResult Index()
 {
 return Content(DateTime.Now.ToString());
 }

The above example indicates that the content of the page will be cached on the client for 100 seconds. In other words, a Cache-Control header is added to the Response header and max-age=100 is set. The following are the attributes supported by this feature:

In addition, ResponseCacheAttribute also supports a CacheProfileName attribute so that the globally set profile information configuration can be read for caching. The example is as follows:

 [ResponseCache(CacheProfileName = "MyProfile" )]
 public IActionResult Index()
 {
 return Content(DateTime.Now.ToString());
 } 
 
 public   void ConfigureServices(IServiceCollection services)
 {
    services.Configure(options => { options.CacheProfiles.Add( "MyProfile" , new CacheProfile { Duration = 100 }); }); } 
 
  

By adding a personality setting named MyProfile to the CacheProfiles property value of MvcOptions, you can use this configuration information on all Actions.

Other things we are already familiar with

We may be very familiar with the following content because we have used it in previous MVC versions. These contents exist as properties of MvcOptions. The specific function list is as follows (I will not describe them one by one):

1.Filters

2. ModelBinders

3.ModelValidatorProviders

4.ValidationExcludeFilters

5.ValueProviderFactories

Two more:

MaxModelValidationErrors

Set model validation to display the highest number of errors.

RespectBrowserAcceptHeader

When using the content agreement function of Web API, whether to comply with the definition of Accept Header. By default, when the media type is */*, the Accept header is ignored. If set to true, it is not ignored.