【热闻】Asp.net core mapcontrollers 背后干了些啥

1.背景

当我们在写webapi的时候我们发现，框架自动帮我们写好了 app.MapControllers(),看注释写的是帮我们将controllerl里面的action映射为我们的终结点，那具体是怎么弄得呢，我觉得可以仔细研究一下，看一下背后的逻辑.

2.开始研究，用dnspy看一下源码

public static ControllerActionEndpointConventionBuilder MapControllers(this IEndpointRouteBuilder endpoints){    //确保依赖的服务已经注册 可以进去看看帮我们注入了哪些东西，后面的代码可以看到它们身影ControllerEndpointRouteBuilderExtensions.EnsureControllerServices(endpoints);return ControllerEndpointRouteBuilderExtensions.GetOrCreateDataSource(endpoints).DefaultBuilder;}//接上面,创建endpoint数据源private static ControllerActionEndpointDataSource GetOrCreateDataSource(IEndpointRouteBuilder endpoints){ControllerActionEndpointDataSource controllerActionEndpointDataSource = endpoints.DataSources.OfType().FirstOrDefault();if (controllerActionEndpointDataSource == null){                //相关服务OrderedEndpointsSequenceProviderCache requiredService = endpoints.ServiceProvider.GetRequiredService();                //获取数据源controllerActionEndpointDataSource = endpoints.ServiceProvider.GetRequiredService().Create(requiredService.GetOrCreateOrderedEndpointsSequenceProvider(endpoints));endpoints.DataSources.Add(controllerActionEndpointDataSource);}return controllerActionEndpointDataSource;}

重点就是 ControllerActionEndpointDataSourceFactory.Create()函数帮我们构建数据源。

controllerActionEndpointDataSourceFactory

internal class ControllerActionEndpointDataSourceFactory    {        private readonly ControllerActionEndpointDataSourceIdProvider _dataSourceIdProvider;        private readonly IActionDescriptorCollectionProvider _actions;        private readonly ActionEndpointFactory _factory;        public ControllerActionEndpointDataSourceFactory(            ControllerActionEndpointDataSourceIdProvider dataSourceIdProvider,            //这个很重要，为我们提供controller action的信息,具体实现类应该是            //ActionDescriptorCollectionProvider            IActionDescriptorCollectionProvider actions,            ActionEndpointFactory factory)        {            _dataSourceIdProvider = dataSourceIdProvider;            _actions = actions;            _factory = factory;        }        public ControllerActionEndpointDataSource Create(OrderedEndpointsSequenceProvider orderProvider)        {               //直接new一个 datasource            return new ControllerActionEndpointDataSource(_dataSourceIdProvider, _actions, _factory, orderProvider);        }    }

终于看到我们的datascource了，所以进去自己看看，如果构建的endpoint.以及最终实现的类是哪个。直接点进去类，可以看到类的构造函数（没贴出来）,实际上当我们第一次启动应用的时候，endpoint是没有构建出来的，直到第一次访问，才会进行初始化. 可以看到调用链 Initialize() =>UpdateEndpoints()=>CreateEndpoints()

(资料图片仅供参考)

internal abstract class ActionEndpointDataSourceBase : EndpointDataSource, IDisposable{     //获取endpoints     public override IReadOnlyList Endpoints        {            get            {                Initialize();                            return _endpoints;            }        }    private void Initialize()        {            if (_endpoints == null)            {                lock (Lock)                {                    if (_endpoints == null)                    {                        UpdateEndpoints();                    }                }            }        }        private void UpdateEndpoints()        {            lock (Lock)            {                var endpoints = CreateEndpoints(_actions.ActionDescriptors.Items, Conventions);                // See comments in DefaultActionDescriptorCollectionProvider. These steps are done                // in a specific order to ensure callers always see a consistent state.                // Step 1 - capture old token                var oldCancellationTokenSource = _cancellationTokenSource;                // Step 2 - update endpoints                _endpoints = endpoints;                // Step 3 - create new change token                _cancellationTokenSource = new CancellationTokenSource();                _changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);                // Step 4 - trigger old token                oldCancellationTokenSource?.Cancel();            }        }}internal class ControllerActionEndpointDataSource:ActionEndpointDataSourceBase{     protected override List CreateEndpoints(IReadOnlyList actions, IReadOnlyList> conventions)        {            var endpoints = new List();            var keys = new HashSet(StringComparer.OrdinalIgnoreCase);            // MVC guarantees that when two of it"s endpoints have the same route name they are    //equivalent.            // However, Endpoint Routing requires Endpoint Names to be unique.            var routeNames = new HashSet(StringComparer.OrdinalIgnoreCase);            // For each controller action - add the relevant endpoints.            // 1. If the action is attribute routed, we use that information verbatim            // 2. If the action is conventional routed            //      a. Create a *matching only* endpoint for each action X route (if possible)            //      b. Ignore link generation for now            for (var i = 0; i < actions.Count; i++)            {                if (actions[i] is ControllerActionDescriptor action)                {                    //逻辑重点，为每个action构建一个endpoint.                    _endpointFactory.AddEndpoints(endpoints, routeNames, action, _routes, conventions, CreateInertEndpoints);                    if (_routes.Count > 0)                    {                        // If we have conventional routes, keep track of the keys so we can create                        // the link generation routes later.                        foreach (var kvp in action.RouteValues)                        {                            keys.Add(kvp.Key);                        }                    }                }            }            // Now create a *link generation only* endpoint for each route. This gives us a very            // compatible experience to previous versions.            for (var i = 0; i < _routes.Count; i++)            {                var route = _routes[i];                _endpointFactory.AddConventionalLinkGenerationRoute(endpoints, routeNames, keys, route, conventions);            }            return endpoints;        }}

可以看到我们针对于每个action构建一个endpoint，AddEndpoints()所以继续进去看看逻辑。

public void AddEndpoints( List endpoints, HashSet routeNames,ActionDescriptor action,IReadOnlyList routes,IReadOnlyList> conventions, bool createInertEndpoints){    //不走的逻辑 代码被我省略删除 路由模板不为空。    if (action.AttributeRouteInfo?.Template != null){                //构建出来处理去请求的委托.很重要        var requestDelegate = CreateRequestDelegate(action) ?? _requestDelegate;        //属性路由模板                var attributeRoutePattern = RoutePatternFactory.Parse(action.AttributeRouteInfo.Template);                // Modify the route and required values to ensure required values can be successfully subsituted.                // Subsitituting required values into an attribute route pattern should always succeed.                var (resolvedRoutePattern, resolvedRouteValues) = ResolveDefaultsAndRequiredValues(action, attributeRoutePattern);                var updatedRoutePattern = _routePatternTransformer.SubstituteRequiredValues(resolvedRoutePattern, resolvedRouteValues);               //省略不重要代码                var builder = new RouteEndpointBuilder(requestDelegate, updatedRoutePattern, action.AttributeRouteInfo.Order)                {                    DisplayName = action.DisplayName,                };//添加action data到builder                AddActionDataToBuilder(                    builder,                    routeNames,                    action,                    action.AttributeRouteInfo.Name,                    dataTokens: null,                    action.AttributeRouteInfo.SuppressLinkGeneration,                    action.AttributeRouteInfo.SuppressPathMatching,                    conventions,                    perRouteConventions: Array.Empty>());                endpoints.Add(builder.Build());    }}

CreateRequestDelegate可以看到构建处理器的逻辑，我们进去看看，由于是ioc注入的容器所以我们需要找到实现类。实现类是 ControllerRequestDelegateFactory类

ControllerRequestDelegateFactory

private RequestDelegate? CreateRequestDelegate(ActionDescriptor action, RouteValueDictionary? dataTokens = null)        {            foreach (var factory in _requestDelegateFactories)            {//看来我们可以注入我们的处理器逻辑，需要注明一下顺序(或者是我记得后来注入的在最前面？)                var requestDelegate = factory.CreateRequestDelegate(action, dataTokens);                if (requestDelegate != null)                {                    return requestDelegate;                }            }            return null;        }// ControllerRequestDelegateFactory方法public RequestDelegate? CreateRequestDelegate(ActionDescriptor actionDescriptor, RouteValueDictionary? dataTokens)        { //省略不重要代码//针对于 context的委托.非常完美            return context =>            {                RouteData routeData;                if (dataTokens is null or { Count: 0 })                {                    routeData = new RouteData(context.Request.RouteValues);                }                else                {                    routeData = new RouteData();                    routeData.PushState(router: null, context.Request.RouteValues, dataTokens);                }                var actionContext = new ActionContext(context, routeData, actionDescriptor);                var controllerContext = new ControllerContext(actionContext)                {                    // PERF: These are rarely going to be changed, so let"s go copy-on-write.                    ValueProviderFactories = new CopyOnWriteList(_valueProviderFactories)                };                controllerContext.ModelState.MaxAllowedErrors = _maxModelValidationErrors;   //实际上这点很重要，这里是帮助我们构建controller类的，因为控制器类没有注入ioc容器                var (cacheEntry, filters) = _controllerActionInvokerCache.GetCachedResult(controllerContext);                //很重要的一个东西，直接把我们引入到mvc的世界中,各种filter逻辑都在这                var invoker = new ControllerActionInvoker(                    _logger,                    _diagnosticListener,                    _actionContextAccessor,                    _mapper,                    controllerContext,                    cacheEntry,                    filters);                return invoker.InvokeAsync();            };        }

看了半天找到了构建controller类的逻辑，那我们进去看看，既然没有注入到ioc，那么是如何构建的呢.进去getcacheResult中看看。

Controller类的生成逻辑

public (ControllerActionInvokerCacheEntry cacheEntry, IFilterMetadata[] filters) GetCachedResult(ControllerContext controllerContext)        {            var actionDescriptor = controllerContext.ActionDescriptor;              // We don"t care about thread safety here            if (cacheEntry is null)            {                //省略 部分代码                //这个是重点，实际上是一个委托，为我们生成controller,下面有代码                var controllerFactory =_controllerFactoryProvider.CreateControllerFactory(actionDescriptor);                var controllerReleaser = _controllerFactoryProvider.CreateAsyncControllerReleaser(actionDescriptor);                // 省略 部分代码                cacheEntry = new ControllerActionInvokerCacheEntry(                    filterFactoryResult.CacheableFilters,                    controllerFactory,                    controllerReleaser,                    propertyBinderFactory,                    objectMethodExecutor,                    actionMethodExecutor);                actionDescriptor.CacheEntry = cacheEntry;            }    // 省略 ......            return (cacheEntry, filters);        }

逻辑是一个provider构建委托生成的,注入的实现类是 ControllerFactoryProvider 看看逻辑

ControllerFactoryProvider

public Func CreateControllerFactory(ControllerActionDescriptor descriptor)        {            //省略 代码            var controllerType = descriptor.ControllerTypeInfo?.AsType();            if (_factoryCreateController != null)            {   //第一种逻辑                return _factoryCreateController;            }            var controllerActivator = _activatorProvider.CreateActivator(descriptor);            var propertyActivators = GetPropertiesToActivate(descriptor);    //第二种逻辑            object CreateController(ControllerContext controllerContext)            {                var controller = controllerActivator(controllerContext);                for (var i = 0; i < propertyActivators.Length; i++)                {                    var propertyActivator = propertyActivators[i];                    propertyActivator(controllerContext, controller);                }                return controller;            }            return CreateController;        }

返回生成controller类的委托有两种逻辑 ，实际上我们走的是第一种 即 _factoryCreateController ，它在构造的时候被初始化为 _factoryCreateController = controllerFactory.CreateController;controllerFactory类又是哪个类呢，实际上是我们注入的DefaultControllerFactory 类，很熟悉把，因为以前的版本也是这么做的

DefaultControllerFactory

public object CreateController(ControllerContext context)        {         //重点代码            var controller = _controllerActivator.Create(context);            foreach (var propertyActivator in _propertyActivators)            {                propertyActivator.Activate(context, controller);            }            return controller;        }

根据你的一个controllercontext生成我们的控制类，_controllerActivator的实现类实际上我们注入的是 DefaultControllerActivator，进去具体看看

DefaultControllerActivator

public object Create(ControllerContext controllerContext)        {            //核心代码 删除了一些代码            var controllerTypeInfo = controllerContext.ActionDescriptor.ControllerTypeInfo;            var serviceProvider = controllerContext.HttpContext.RequestServices;            return _typeActivatorCache.CreateInstance