• 模拟ASP.NET Core MVC设计与实现

    前几天有人在我的《ASP.NET Core框架揭秘》读者群跟我留言说：“我最近在看ASP.NET Core MVC的源代码，发现整个系统太复杂，涉及的东西太多，完全找不到方向，你能不能按照《200行代码，7个对象——让你了解ASP.NET Core框架的本质》这篇文章思路剖析一下MVC框架”。对于ASP.NET Core MVC框架的涉及和实现，说难也难，毕竟一个Model Binding就够很多人啃很久，其实说简单也简单，因为整个流程是很清晰的。ASP.NET Core MVC支持基于Controller和Page的两种编程模式，虽然编程方式看起来不太一样，底层针对请求的处理流程其实是一致的。接下来，我同样使用简单的代码构建一个Mini版的MVC框架，让大家了解一下ASP.NET Core MVC背后的总体设计，以及针对请求的处理流程。[源代码从这里下载]。

    一、描述Action方法二、注册路由终结点三、绑定Action方法参数四、执行Action方法五、响应执行结果六、编排整个处理流程七、跑起来看看

    一、描述Action方法

    MVC应用提供的功能体现在一个个Action方法上，所以MVC框架定义了专门的类型ActionDescriptor来描述每个有效的Action方法。但是Action方法和ActionDescriptor对象并非一对一的关系，而是一对多的关系。具体来说，采用“约定路由”的Action方法对应一个ActionDescriptor对象，如果采用“特性路由”，MVC框架会针对每个注册的路由创建一个ActionDescriptor。Action方法与ActionDescriptor之间的映射关系可以通过如下这个演示实例来验证。如代码片段所示，我们调用MapControllerRoute扩展方法注册了4个“约定路由”。HomeController类中定义了两个合法的Action方法，其中方法Foo采用“约定路由”，而方法Bar通过标注的两个HttpGetAttribute特性注册了两个“特性路由”。按照上述的规则，将有三个ActionDescriptor被创建出来，方法Foo有一个，而方法Bar有两个。

    1. var builder = WebApplication.CreateBuilder(args);
    2. builder.Services.AddControllers();
    3. var app = builder.Build();
    4. app.MapControllers();
    5. app.MapControllerRoute("v1", "v1/{controller}/{action}");
    6. app.MapControllerRoute("v2", "v2/{controller}/{action}");
    7. app.MapControllerRoute("v3", "v2/{controllerx}/{action}");
    8. app.MapControllerRoute("v3", "v4/{controller}/{actionx}");
    9.  
    10. app.MapGet("/actions", (IActionDescriptorCollectionProvider provider) => {
    11.     var actions = provider.ActionDescriptors.Items;
    12.     var builder = new StringBuilder();
    13.     foreach (var action in actions.OfType())
    14.     {
    15.         builder.AppendLine($"{action.ControllerTypeInfo.Name}.{action.MethodInfo.Name}({action.AttributeRouteInfo?.Template ?? "N/A"})");
    16.     }
    17.     return builder.ToString();
    18. });
    19.  
    20. app.Run("http://localhost:5000");
    21.  
    22. public class HomeController
    23. {
    24.     public string Foo() => $"{nameof(HomeController)}.{nameof(Foo)}";
    25.  
    26.     [HttpGet("home/bar1")]
    27.     [HttpGet("home/bar2")]
    28.     public string Bar() => $"{nameof(HomeController)}.{nameof(Bar)}";
    29. }

    我们注册了一个指向路径“/actions”的路由终结点将所有ActionDescriptor列出来。如代码片段所示，路由处理委托（Lambda表达式）注入了IActionDescriptorCollectionProvider 对象，我们利用它的ActionDescriptors属性得到当前应用承载的所有ActionDescriptor对象。我们将其转化成ControllerActionDescriptor（派生于ActionDescriptor，用于描述定义在Controller类型中的Action方法，另一个派生类PageActionDescriptor用于描述定义在Page类型的Action方法），并将对应的Controller类型和方法名称，以及特性路由模板输出来。如下所示的输出结果验证了上述针对Action方法与ActionDescriptor映射关系的论述。

    image

    在模拟框架中，我们ActionDescriptor类型作最大的简化。如代码片段所示，创建一个ActionDescriptor对象时只需提供描述目标Action方法的MethodInfo对象（必需），和一个用来定义特性路由的IRouteTemplateProvider对象（可选，仅针对特性路由）。我们利用MethodInfo的声明类型得到Controller的类型，将剔除“Controller”后缀的类型名称作为ControllerName属性（表示Controller的名称），作为Action名称的ActionName属性则直接返回方法名称。Parameters属性返回一个ParameterDescriptor数组，而根据ParameterInfo对象构建的ParameterDescriptor是对参数的描述。

    1. public class ActionDescriptor
    2. {
    3.     public MethodInfo MethodInfo { get; }
    4.     public IRouteTemplateProvider? RouteTemplateProvider { get; }
    5.     public string ControllerName { get; }
    6.     public string ActionName { get; }
    7.     public ParameterDescriptor[] Parameters { get; }
    8.     public ActionDescriptor(MethodInfo methodInfo, IRouteTemplateProvider? routeTemplateProvider)
    9.     {
    10.         MethodInfo = methodInfo;
    11.         RouteTemplateProvider = routeTemplateProvider;
    12.         ControllerName = MethodInfo.DeclaringType!.Name;
    13.         ControllerName = ControllerName[..^"Controller".Length];
    14.         ActionName = MethodInfo.Name;
    15.         Parameters = methodInfo.GetParameters().Select(it => new ParameterDescriptor(it)).ToArray();
    16.     }
    17. }
    18.  
    19. public class ParameterDescriptor(ParameterInfo parameterInfo)
    20. {
    21.     public ParameterInfo ParameterInfo => parameterInfo;
    22. }

    当前应用涉及的所有ActionActionDescriptor由IActionDescriptorCollectionProvider对象的ActionDescriptors属性来提供。实现类型ActionDescriptorCollectionProvider 从当前启动程序集中提取有效的Controller类型，并将定义其中的有效Action方法转换成ActionDescriptor对象。用于定义“特性路由”的IRouteTemplateProvider对象来源于标注到方法上的特性（简单起见，我们忽略了标注到Controller类型上的特性），比如HttpGetAttribute特性等，同一个Action方法针对注册的特性路由来创建ActionDescriptor就体现在这里。

    1. public interface IActionDescriptorCollectionProvider
    2. {
    3.     IReadOnlyList<ActionDescriptor> ActionDescriptors { get; }
    4. }
    5.  
    6. public class ActionDescriptorCollectionProvider : IActionDescriptorCollectionProvider
    7. {
    8.     private readonly Assembly _assembly;
    9.     private List<ActionDescriptor>? _actionDescriptors;
    10.     public IReadOnlyList<ActionDescriptor> ActionDescriptors => _actionDescriptors ??= Resolve(_assembly.GetExportedTypes()).ToList();
    11.  
    12.     public ActionDescriptorCollectionProvider(IWebHostEnvironment environment)
    13.     {
    14.         var assemblyName = new AssemblyName(environment.ApplicationName);
    15.         _assembly = Assembly.Load(assemblyName);
    16.     }
    17.  
    18.     private IEnumerable<ActionDescriptor> Resolve(IEnumerable<Type> types)
    19.     {
    20.         var methods = types
    21.             .Where(IsValidController)
    22.             .SelectMany(type => type.GetMethods()
    23.             .Where(method => method.DeclaringType == type && IsValidAction(method)));
    24.  
    25.         foreach (var method in methods)
    26.         {
    27.             var providers = method.GetCustomAttributes().OfType<IRouteTemplateProvider>();
    28.             if (providers.Any())
    29.             {
    30.                 foreach (var provider in providers)
    31.                 {
    32.                     yield return new ActionDescriptor(method, provider);
    33.                 }
    34.             }
    35.             else
    36.             {
    37.                 yield return new ActionDescriptor(method, null);
    38.             }
    39.         }
    40.     }
    41.  
    42.     private static bool IsValidController(Type candidate) => candidate.IsPublic && !candidate.IsAbstract && candidate.Name.EndsWith("Controller");
    43.     private static bool IsValidAction(MethodInfo methodInfo) => methodInfo.IsPublic | !methodInfo.IsAbstract;
    44. }

    二、注册路由终结点

    MVC利用“路由”对外提供服务，它会将每个ActionDescriptor转换成“零到多个”路由终结点。

    ActionDescriptor与终结点之间的对应关系为什么是“零到多”，而不是“一对一”或者“一对多”呢？这也与Action方法采用的路由默认有关，采用特性路由的ActionDescriptor（RouteTemplateProvider 属性不等于Null）总是对应着一个确定的路由，但是如何为采用“约定路由”的ActionDescriptor创建对应的终结点，则取决于多少个约定路由与之匹配。针对每一个基于“约定”路由的ActionDescriptor，系统会为每个与之匹配的路由创建对应的终结点。如果没有匹配的约定路由，对应的Action方法自然就不会有对应的终结点。

    我还是利用上面演示实例来说明ActionDescriptor与路由终结点之间的映射关系。为此我们注册如下这个指向路径“/endpoints”的路由终结点，我们通过注入的EndpointDataSource 对象得到终结点列表。由于针对某个Action方法创建的路由终结点都会将ActionDescriptor对象作为元数据，所以我们试着将它（具体类型为ControllerActionDescriptor）提取出来，并输出Controller类型和Action方法的名称，以及路由模板。

    1. ...
    2. app.MapGet("/endpoints", (EndpointDataSource source) =>
    3. {
    4.     var builder = new StringBuilder();
    5.     foreach (var endpoint in source.Endpoints.OfType<RouteEndpoint>())
    6.     {
    7.         var action = endpoint.Metadata.GetMetadata<ControllerActionDescriptor>();
    8.         if (action is not null)
    9.         {
    10.             builder.AppendLine($"{action.ControllerTypeInfo.Name}.{action.MethodInfo.Name}({endpoint.RoutePattern.RawText})");
    11.         }
    12.     }
    13.     return builder.ToString();
    14. });
    15. ...

    从如下所示的输出结果可以看出，由于Action方法Bar采用“特性路由”，所以对应的ActionDescriptor分别对应着一个终结点。采用约定路由的Foo方法虽然只有一个ActionDescriptor，但是注册的4个约定路由有两个与它匹配（两个必要的路由参数“controller”和“action”需要定义在路由模板中），所以它也具有两个终结点。

    image

    接下来我们在模拟框架中以最简单的方式完成“路由注册”。我们知道每个路由终结点由“路由模式”和“路由处理器”这两个核心元素构成，前者对应一个RoutePattern对象，由注册的路由信息构建而成，后者体现为一个用来处理请求的RequestDelegate委托。一个MVC应用绝大部分的请求处理工作都落在IActionInvoker对象上，所以作为路由处理器的RequestDelegate委托只需要将请求处理任务“移交”给这个对象就可以了。如代码片段所示，IActionInvoker接口定义了一个无参、返回类型为Task的InvokeAsync方法。IActionInvoker不是一个单例对象，而是针对每个请求单独创建的，创建它的工厂由IActionInvokerFactory接口表示。如代码片段所示，定义在该接口的工厂方法CreateInvoker利用指定的ActionContext上下文来创建返回的IActionInvoker对象。ActionContext可以视为MVC应用的请求上下文，我们的模拟框架同样对它做了最大的简化，将它定义对HttpContext上下文和ActionDescriptor对象的封装。

    1. public interface IActionInvoker
    2. {
    3.     Task InvokeAsync();
    4. }
    5.  
    6. public interface IActionInvokerFactory
    7. {
    8.     IActionInvoker CreateInvoker(ActionContext actionContext);
    9. }
    10.  
    11. public class ActionContext(HttpContext httpContext, ActionDescriptor actionDescriptor)
    12. {
    13.     public HttpContext HttpContext => httpContext;
    14.     public ActionDescriptor ActionDescriptor => actionDescriptor;
    15. }

    我们将路由（终结点）注册实现在一个派生自EndpointDataSource的ActionEndpointDataSource类型中 。对于注册的每个终结点，作为处理器的RequestDelegate委托指向HandleAsync方法，可以看出这个方法的定义非常简单：它从当前终结点中以元数据的形式将ActionDescriptor对象，然后利用它与当前HttpContext将ActionContext上下文创建出来。我们将此ActionContext上下文传递给IActionInvokerFactory工厂将IActionInvoker对象创建出来，并利用它完成后续的请求处理。

    1. public class ActionEndpointDataSource : EndpointDataSource
    2. {   
    3.  
    4.     ...
    5.     private static Task HandleRequestAsync(HttpContext httpContext)
    6.     {
    7.         var endpoint = httpContext.GetEndpoint() ?? throw new InvalidOperationException("No endpoint is matched to the current request.");
    8.         var actionDescriptor = endpoint.Metadata.GetMetadata() ?? throw new InvalidOperationException("No ActionDescriptor is attached to the endpoint as metadata.");
    9.         var actionContext = new ActionContext(httpContext, actionDescriptor);
    10.         return httpContext.RequestServices.GetRequiredService().CreateInvoker(actionContext).InvokeAsync();
    11.     }
    12. }

    ActionEndpointDataSource 定义了一个AddRoute方法来定义约定路由，注册的约定路由被存储在字段_conventionalRoutes所示的列表中。该方法返回一个EndpointConventionBuilder 对象，后者实现了IEndpointConventionBuilder 接口，我们可以利用它对添加的约定约定路由作进一步设置（比如添加元数据）。

    1. public class ActionEndpointDataSource : EndpointDataSource
    2. {
    3.  
    4.     private readonly List<(string RouteName, string Template, RouteValueDictionary? Defaults, IDictionary<string, object?>? Constraints, RouteValueDictionary? DataTokens, List<Action<EndpointBuilder>> Conventions, List> FinallyConventions)> _conventionalRoutes = new();
    6.     public IEndpointConventionBuilder AddRoute(string routeName, string pattern, RouteValueDictionary? defaults, IDictionary<string, object?>? constraints, RouteValueDictionary? dataTokens)
    7.     {
    8.         var conventions = new List<Action<EndpointBuilder>>();
    9.         var finallyConventions = new List<Action<EndpointBuilder>>();
    10.         _conventionalRoutes.Add((routeName, pattern, defaults, constraints, dataTokens, conventions, finallyConventions));
    11.         return new EndpointConventionBuilder(conventions, finallyConventions);
    12.     }
    13.  
    14.  
    15.     private sealed class EndpointConventionBuilder : IEndpointConventionBuilder
    16.     {
    17.         private readonly List<Action<EndpointBuilder>> _conventions;
    18.         private readonly List<Action<EndpointBuilder>> _finallyConventions;
    20.         public EndpointConventionBuilder(List<Action<EndpointBuilder>> conventions, List> finallyConventions)
    21.         {
    22.             _conventions = conventions;
    23.             _finallyConventions = finallyConventions;
    24.         }
    25.  
    26.         public void Add(Action<EndpointBuilder> convention) => _conventions.Add(convention);
    27.         public void Finally(Action<EndpointBuilder> finallyConvention) => _finallyConventions.Add(finallyConvention);
    28.     }
    29. }

    ActionEndpointDataSource 针对终结点的创建并不复杂：在利用IActionDescriptorCollectionProvider 对象得到所有的ActionDescriptor对象后，它将每个ActionDescriptor对象交付给CreateEndpoints来创建相应的终结点。针对约定路由的终结点列表由CreateConventionalEndpoints方法进行创建，一个ActionDescriptor对象对应”零到多个“终结点的映射规则就体现在这里。针对特性路由的ActionDescriptor对象则在CreateAttributeEndpoint方法中转换成一个单一的终结点。EndpointDataSource还通过GetChangeToken方法返回的IChangeToken 对象感知终结点的实时变化，真正的MVC框架正好利用了这一点实现了”动态模块加载“的功能。我们的模拟框架直接返回一个单例的NullChangeToken对象。

    1. public class ActionEndpointDataSource : EndpointDataSource
    2. {
    3.     private readonly IServiceProvider _serviceProvider;
    4.     private readonly IActionDescriptorCollectionProvider _actions;
    5.     private readonly RoutePatternTransformer _transformer;
    6.     private readonly List<Action<EndpointBuilder>> _conventions = new();
    7.     private readonly List<Action<EndpointBuilder>> _finallyConventions = new();
    8.     private int _routeOrder;
    9.  
    10.  
    11.     private List<Endpoint>? _endpoints;
    12.     private readonly List<(string RouteName, string Template, RouteValueDictionary? Defaults, IDictionary<string, object?>? Constraints, RouteValueDictionary? DataTokens, List<Action<EndpointBuilder>> Conventions, List> FinallyConventions)> _conventionalRoutes = new();
    14.     public ActionEndpointDataSource(IServiceProvider serviceProvider)
    15.     {
    16.         _serviceProvider = serviceProvider;
    17.         _actions = serviceProvider.GetRequiredService<IActionDescriptorCollectionProvider>();
    18.         _transformer = serviceProvider.GetRequiredService<RoutePatternTransformer>();
    19.         DefaultBuilder = new EndpointConventionBuilder(_conventions, _finallyConventions);
    20.     }
    21.  
    22.     public override IReadOnlyList<Endpoint> Endpoints => _endpoints ??= _actions.ActionDescriptors.SelectMany(CreateEndpoints).ToList();
    23.     public override IChangeToken GetChangeToken() => NullChangeToken.Singleton;
    24.     public IEndpointConventionBuilder AddRoute(string routeName, string pattern, RouteValueDictionary? defaults, IDictionary<string, object?>? constraints, RouteValueDictionary? dataTokens)
    25.     {
    26.         var conventions = new List<Action<EndpointBuilder>>();
    27.         var finallyConventions = new List<Action<EndpointBuilder>>();
    28.         _conventionalRoutes.Add((routeName, pattern, defaults, constraints, dataTokens, conventions, finallyConventions));
    29.  
    30.     }
    31.  
    32.  
    33.     private IEnumerable<Endpoint> CreateEndpoints(ActionDescriptor actionDescriptor)
    34.     {
    35.         var routeValues = new RouteValueDictionary
    36.         {
    37.             {"controller", actionDescriptor.ControllerName },
    38.             { "action", actionDescriptor.ActionName }
    39.         };
    40.         var attributes = actionDescriptor.MethodInfo.GetCustomAttributes(true).Union(actionDescriptor.MethodInfo.DeclaringType!.GetCustomAttributes(true));
    41.         var routeTemplateProvider = actionDescriptor.RouteTemplateProvider;
    42.         if (routeTemplateProvider is null)
    43.         {
    44.             foreach (var endpoint in CreateConventionalEndpoints(actionDescriptor, routeValues, attributes))
    45.             {
    46.                 yield return endpoint;
    47.             }
    48.         }
    49.         else
    50.         {
    51.            yield return  CreateAttributeEndpoint(actionDescriptor, routeValues, attributes));
    52.         }
    53.     }
    54.  
    55.  
    56.     private IEnumerable<Endpoint> CreateConventionalEndpoints(ActionDescriptor actionDescriptor, RouteValueDictionary routeValues, IEnumerable<object> attributes )
    57.     {
    58.         foreach (var (routeName, template, defaults, constraints, dataTokens, conventionals, finallyConventionals) in _conventionalRoutes)
    59.         {
    60.             var pattern = RoutePatternFactory.Parse(template, defaults, constraints);
    61.             pattern = _transformer.SubstituteRequiredValues(pattern, routeValues);
    62.             if (pattern is not null)
    63.             {
    64.                 var builder = new RouteEndpointBuilder(requestDelegate: HandleRequestAsync, routePattern: pattern, _routeOrder++)
    65.                 {
    66.                     ApplicationServices = _serviceProvider
    67.                 };
    68.                 builder.Metadata.Add(actionDescriptor);
    69.                 foreach (var attribute in attributes)
    70.                 {
    71.                     builder.Metadata.Add(attribute);
    72.                 }
    73.                 yield return builder.Build();
    74.             }
    75.         }
    76.     }
    77.  
    78.  
    79.     private Endpoint CreateAttributeEndpoint(ActionDescriptor actionDescriptor, RouteValueDictionary routeValues, IEnumerable<object> attributes)
    80.     {
    81.         var routeTemplateProvider = actionDescriptor.RouteTemplateProvider!;
    82.         var pattern = RoutePatternFactory.Parse(routeTemplateProvider.Template!);
    83.         var builder = new RouteEndpointBuilder(requestDelegate: HandleRequestAsync, routePattern: pattern, _routeOrder++)
    84.         {
    85.             ApplicationServices = _serviceProvider
    86.         };
    87.         builder.Metadata.Add(actionDescriptor);
    88.         foreach (var attribute in attributes)
    89.         {
    90.             builder.Metadata.Add(attribute);
    91.         }
    92.         if (routeTemplateProvider is IActionHttpMethodProvider httpMethodProvider)
    93.         {
    94.             builder.Metadata.Add(new HttpMethodActionConstraint(httpMethodProvider.HttpMethods));
    95.         }
    96.         return builder.Build();
    97.     }
    98. }

    三、绑定Action方法参数

    现在我们完成了路由（终结点）注册，此时匹配的请求总是会被路由到对应的终结点，后者将利用IActionInvokerFactory工厂创建的IActionInvoker对象来处理请求。IActionInvoker最终需要调用对应的Action方法，但是要完成针对目标方法的调用，得先绑定其所有参数，MVC框架为此构建了一套名为“模型绑定（Model Binding）”的系统来完成参数绑定的任务，毫无疑问这是MVC框架最为复杂的部分。在我么简化的模拟框架中，我们将针对单个参数的绑定交给IArgumentBinder对象来完成。

    如代码片段所示，定义在IArgumentBinder中的BindAsync方法具有两个参数，一个是当前ActionContext上下文，另一个是描述目标参数的ParameterDescriptor 对象。该方法返回类型为ValueTask，泛型参数代表的object就是执行Action方法得到的返回值（对于返回类型为void的方法，这个值总是Null）。默认实现的ArgumentBinder类型完成了最基本的参数绑定功能，它可以帮助我们完成源自依赖服务、请求查询字符串、路由参数、主体内容（默认采用JSON反序列化）和默认值的参数绑定。

    1. public interface IArgumentBinder
    2. {
    3.     public ValueTask<object?> BindAsync(ActionContext actionContext, ParameterDescriptor parameterDescriptor);
    4. }
    5.  
    6. public class ArgumentBinder : IArgumentBinder
    7. {
    8.     private readonly ConcurrentDictionary<Type, object?> _defaults = new();
    9.     private readonly MethodInfo _method = typeof(ArgumentBinder).GetMethod(nameof(GetDefaultValue))!;
    10.     public ValueTask<object?> BindAsync(ActionContext actionContext, ParameterDescriptor parameterDescriptor)
    11.     {
    12.         var requestServices = actionContext.HttpContext.RequestServices;
    13.         var parameterInfo = parameterDescriptor.ParameterInfo;
    14.         var parameterName = parameterInfo.Name!;
    15.         var parameterType = parameterInfo.ParameterType;
    16.  
    17.         // From registered service
    18.         var result = requestServices.GetService(parameterType);
    19.         if (result is not null)
    20.         {
    21.             return ValueTask.FromResult(result)!;
    22.         }
    23.  
    24.         // From query, route, body
    25.         var request = actionContext.HttpContext.Request;
    26.         if (request.Query.TryGetValue(parameterName, out var value1))
    27.         {
    28.             return ValueTask.FromResult(Convert.ChangeType((string)value1!, parameterType))!;
    29.         }
    30.         if (request.RouteValues.TryGetValue(parameterName, out var value2))
    31.         {
    32.             return ValueTask.FromResult(Convert.ChangeType(value2, parameterType)!)!;
    33.         }
    34.         if (request.ContentLength > 0)
    35.         {
    36.             return JsonSerializer.DeserializeAsync(request.Body, parameterType);
    37.         }
    38.  
    39.         // From default value
    40.         var defaultValue = _defaults.GetOrAdd(parameterType, type=> _method.MakeGenericMethod(parameterType).Invoke(null,null));
    41.         return ValueTask.FromResult(defaultValue);
    42.     }
    43.     public static T GetDefaultValue<T>() => default!;
    44. }

    四、执行Action方法

    在模拟框架中，针对目标Action方法的执行体现在如下所示的IActionMethodExecutor接口的Execute方法上，该方法的三个参数分别代表Controller对象、描述目标Action方法的ActionDescriptor和通过“参数绑定”得到的参数列表。Execute方法的返回值就是执行目标Action方法的返回值。如下所示的实现类型ActionMethodExecutor 利用“表达式树”的方式将Action方法对应的MethodInfo转换成对应的Func委托，并利用后者执行Action方法。

    1. public interface IActionMethodExecutor
    2. {
    3.     object? Execute(object controller, ActionDescriptor actionDescriptor, object?[] arguments);
    4. }
    5.  
    6. public class ActionMethodExecutor : IActionMethodExecutor
    7. {
    8.     private readonly ConcurrentDictionary<MethodInfo, Func<object, object?[], object?>> _executors = new();
    9.     public object? Execute(object controller, ActionDescriptor actionDescriptor, object?[] arguments)
    10.         => _executors.GetOrAdd(actionDescriptor.MethodInfo, CreateExecutor).Invoke(controller, arguments);
    11.     private Func<object, object?[], object?> CreateExecutor(MethodInfo methodInfo)
    12.     {
    13.         var controller = Expression.Parameter(typeof(object));
    14.         var arguments = Expression.Parameter(typeof(object?[]));
    15.  
    16.         var parameters = methodInfo.GetParameters();
    17.         var convertedArguments = new Expression[parameters.Length];
    18.         for (int index = 0; index < parameters.Length; index++)
    19.         {
    20.             convertedArguments[index] = Expression.Convert(Expression.ArrayIndex(arguments, Expression.Constant(index)), parameters[index].ParameterType);
    21.         }
    22.  
    23.         var convertedController = Expression.Convert(controller, methodInfo.DeclaringType!);
    24.         var call = Expression.Call(convertedController, methodInfo, convertedArguments);
    25.         return Expression.Lambda<Func<object, object?[], object?>>(call, controller, arguments).Compile();
    26.     }
    27. }

    五、响应执行结果

    当我们利用IActionMethodExecutor对象成功执行Action方法后，需要进一步处理其返回值。为了统一处理执行Action方法的结果，于是有了如下这个IActionResult接口，具体的处理逻辑实现在ExecuteResultAsync方法中，方法的唯一参数依然是当前ActionContext上下文。我们定义了如下这个JsonResult实现基于JSON的响应。

    1. public interface IActionResult
    2. {
    3.     Task ExecuteResultAsync(ActionContext  actionContext);
    4. }
    5.  
    6. public class JsonResult(object data) : IActionResult
    7. {
    8.     public Task ExecuteResultAsync(ActionContext actionContext)
    9.     {
    10.         var response = actionContext.HttpContext.Response;
    11.         response.ContentType = "application/json";
    12.         return JsonSerializer.SerializeAsync(response.Body, data);
    13.     }
    14. }

    当IActionMethodExecutor成功执行目标方法后，我们会得到作为返回值的Object对象（可能是Null），如果我们能够进一步将它转换成一个IActionResult对象，一切就迎刃而解了，为此我专门定义了如下这个IActionResultConverter接口。如代码片段所示，IActionResultConverter接口的唯一方法ConvertAsync方法会将作为Action方法返回值的Object对象转化成ValueTask对象。

    1. public interface IActionResultConverter
    2. {
    3.     ValueTask<IActionResult> ConvertAsync(object? result);
    4. }
    5.  
    6. public class ActionResultConverter : IActionResultConverter
    7. {
    8.     private readonly MethodInfo _valueTaskConvertMethod = typeof(ActionResultConverter).GetMethod(nameof(ConvertFromValueTask))!;
    9.     private readonly MethodInfo _taskConvertMethod = typeof(ActionResultConverter).GetMethod(nameof(ConvertFromTask))!;
    10.     private readonly ConcurrentDictionary<Type, Func<object, ValueTask<IActionResult>>> _converters = new();
    12.     public ValueTask<IActionResult> ConvertAsync(object? result)
    13.     {
    14.         // Null
    15.         if (result is null)
    16.         {
    17.             return ValueTask.FromResult<IActionResult>(VoidActionResult.Instance);
    18.         }
    19.  
    20.         // Task<IActionResult>
    21.         if (result is Task<IActionResult> taskOfActionResult)
    22.         {
    23.             return new ValueTask<IActionResult>(taskOfActionResult);
    24.         }
    25.  
    26.         // ValueTask<IActionResult>
    27.         if (result is ValueTask<IActionResult> valueTaskOfActionResult)
    28.         {
    29.             return valueTaskOfActionResult;
    30.         }
    31.  
    32.         // IActionResult
    33.         if (result is IActionResult actionResult)
    34.         {
    35.             return ValueTask.FromResult(actionResult);
    36.         }
    37.  
    38.         // ValueTask
    39.         if (result is ValueTask valueTask)
    40.         {
    41.             return Convert(valueTask);
    42.         }
    43.  
    44.         // Task
    45.         var type = result.GetType();
    46.         if (type == typeof(Task))
    47.         {
    48.             return Convert((Task)result);
    49.         }
    50.  
    51.         // ValueTask<T>
    52.         if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>))
    53.         {
    54.             return _converters.GetOrAdd(type, t => CreateValueTaskConverter(t, _valueTaskConvertMethod)).Invoke(result);
    55.         }
    56.  
    57.         // Task<T>
    58.         if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>))
    59.         {
    60.             return _converters.GetOrAdd(type, t => CreateValueTaskConverter(t, _taskConvertMethod)).Invoke(result);
    61.         }
    62.  
    63.         // Object
    64.         return ValueTask.FromResult<IActionResult>(new ObjectActionResult(result));
    65.     }
    66.  
    67.     public static async ValueTask<IActionResult> ConvertFromValueTask<T>(ValueTask<T> valueTask)
    68.     {
    69.         var result = valueTask.IsCompleted ? valueTask.Result : await valueTask;
    70.         return result is IActionResult actionResult ? actionResult : new ObjectActionResult(result!);
    71.     }
    72.  
    73.     public static async ValueTask<IActionResult> ConvertFromTask<T>(Task<T> task)
    74.     {
    75.         var result = await task;
    76.         return result is IActionResult actionResult ? actionResult : new ObjectActionResult(result!);
    77.     }
    78.  
    79.     private static async ValueTask<IActionResult> Convert(ValueTask valueTask)
    80.     {
    81.         if (!valueTask.IsCompleted) await valueTask;
    82.         return VoidActionResult.Instance;
    83.     }
    84.  
    85.     private static async ValueTask<IActionResult> Convert(Task task)
    86.     {
    87.         await task;
    88.         return VoidActionResult.Instance;
    89.     }
    90.  
    91.     private static Func<object, ValueTask<IActionResult>> CreateValueTaskConverter(Type valueTaskType, MethodInfo convertMethod)
    92.     {
    93.         var parameter = Expression.Parameter(typeof(object));
    94.         var convert = Expression.Convert(parameter, valueTaskType);
    95.         var method = convertMethod.MakeGenericMethod(valueTaskType.GetGenericArguments()[0]);
    96.         var call = Expression.Call(method, convert);
    97.         return Expression.Lambda<Func<object, ValueTask<IActionResult>>>(call, parameter).Compile();
    98.     }
    99.  
    100.     private sealed class VoidActionResult : IActionResult
    101.     {
    102.         public static readonly VoidActionResult Instance = new();
    103.         public Task ExecuteResultAsync(ActionContext actionContext) => Task.CompletedTask;
    104.     }
    105.  
    106.     private sealed class ObjectActionResult(object result) : IActionResult
    107.     {
    108.         public Task ExecuteResultAsync(ActionContext actionContext)
    109.         {
    110.             var response = actionContext.HttpContext.Response;
    111.             response.ContentType = "text/plain";
    112.             return response.WriteAsync(result.ToString()!);
    113.         }
    114.     }
    115. }

    作为默认实现的ActionResultConverter 在进行转换的时候，会根据返回值的类型做针对性转换，具体的转换规则如下：

    • Null：根据单例的VoidActionResult对象创建一个ValueTask，VoidActionResult实现的ExecuteResultAsync方法什么都不要做；

    • Task：直接将其转换成ValueTask；

    • ValueTask：直接返回；

    • 实现了IActionResult接口：根据该对象创建ValueTask；

    • ValueTask：调用Convert方法进行转换；

    • Task：调用另一个Convert方法进行转换；

    • ValueTask：调用ConvertFromValueTask方法进行转换；

    • Task：调用ConvertFromTask方法进行转换；

    • 其他：根据返回创建一个ObjectActionResult对象（它会将ToString方法返回的字符串作为响应内容），并创建一个ValueTask对象。

    六、编排整个处理流程

    到目前为止，我们不经能够执行Action方法，还能将方法的返回值转换成ValueTask对象，定义一个完成整个请求处理的IActionInvoker实现类型就很容易了。如代码片段所示，如下这个实现了IActionInvoker接口的ActionInvoker对象是根据当前ActionContext创建的，在实现的InvokeAsync方法中，它利用ActionContext上下文提供的ActionDescriptor解析出Controller类型，并利用针对当前请求的依赖注入容器（IServiceProvider）将Controller对象创建出来。

    1. public class ActionInvoker(ActionContext actionContext) : IActionInvoker
    2. {
    3.     public ActionContext ActionContext { get; } = actionContext;
    4.     public async Task InvokeAsync()
    5.     {
    6.  
    7.         var requestServices = ActionContext.HttpContext.RequestServices;
    8.  
    9.         // Create controller instance
    10.         var controller = ActivatorUtilities.CreateInstance(requestServices, ActionContext.ActionDescriptor.MethodInfo.DeclaringType!);
    11.         try
    12.         {
    13.             // Bind arguments
    14.             var parameters = ActionContext.ActionDescriptor.Parameters;
    15.             var arguments = new object?[parameters.Length];
    16.             var binder = requestServices.GetRequiredService<IArgumentBinder>();
    17.             for (int index = 0; index < parameters.Length; index++)
    18.             {
    19.                 var valueTask = binder.BindAsync(ActionContext, parameters[index]);
    20.                 if (valueTask.IsCompleted)
    21.                 {
    22.                     arguments[index] = valueTask.Result;
    23.                 }
    24.                 else
    25.                 {
    26.                     arguments[index] = await valueTask;
    27.                 }
    28.             }
    29.  
    30.             // Execute action method
    31.             var executor = requestServices.GetRequiredService<IActionMethodExecutor>();
    32.  
    33.             var result = executor.Execute(controller, ActionContext.ActionDescriptor, arguments);
    34.  
    35.             // Convert result to IActionResult
    36.             var converter = requestServices.GetRequiredService<IActionResultConverter>();
    37.             var convert = converter.ConvertAsync(result);
    38.             var actionResult = convert.IsCompleted ? convert.Result : await convert;
    39.  
    40.             // Execute result
    41.             await actionResult.ExecuteResultAsync(ActionContext);
    42.         }
    43.         finally
    44.         {
    45.             (controller as IDisposable)?.Dispose();
    46.         }
    47.     }
    48. }
    49.  
    50. public class ActionInvokerFactory : IActionInvokerFactory
    51. {
    52.     public IActionInvoker CreateInvoker(ActionContext actionContext) => new ActionInvoker(actionContext);
    53. }

    接下来，它同样利用ActionDescriptor得到描述每个参数的ParameterDescriptor对象，并利用IParameterBinder完成参数绑定，最终得到一个传入Action方法的参数列表。接下来ActionInvoker利用IActionMethodExecutor对象成功执行Action方法，并利用IActionResultConverter对象将返回结果转换成IActionResult对象，最终通过执行这个对象完成针对请求的响应工作。如果Controller类型实现了IDisposable接口，在完成了整个处理流程后，我们还会调用其Dispose方法确保资源得到释放。

    七、跑起来看看

    当目前为止，模拟的MVC框架的核心组件均已构建完成，现在我们补充两个扩展方法。如代码片段所示，针对IServiceCollection接口的扩展方法AddControllers2（为了区别于现有的AddControllers，后面的MapControllerRoute2方法命名也是如此）将上述的接口和实现类型注册为依赖服务；针对IEndpointRouteBuilder 接口的扩展方法MapControllerRoute2完成了针对ActionEndpointDataSource的中，并在此基础上注册一个默认的约定路由。（）

    1. public static class Extensions
    2. {
    3.     public static IServiceCollection AddControllers2(this IServiceCollection services)
    4.     {
    5.         services.TryAddSingleton<IActionInvokerFactory, ActionInvokerFactory>();
    6.         services.TryAddSingleton<IActionMethodExecutor, ActionMethodExecutor>();
    7.         services.TryAddSingleton<IActionResultConverter, ActionResultConverter>();
    8.         services.TryAddSingleton<IArgumentBinder, ArgumentBinder>();
    9.         services.TryAddSingleton<IActionDescriptorCollectionProvider, ActionDescriptorCollectionProvider>();
    10.         return services;
    11.     }
    12.  
    13.     public static IEndpointConventionBuilder MapControllerRoute2(
    14.         this IEndpointRouteBuilder endpoints,
    15.         string name,
    16.         [StringSyntax("Route")] string pattern,
    17.         object? defaults = null,
    18.         object? constraints = null,
    19.         object? dataTokens = null)
    20.     {
    21.         var source = new ActionEndpointDataSource(endpoints.ServiceProvider);
    22.         endpoints.DataSources.Add(source);
    23.         return source.AddRoute(
    24.             name,
    25.             pattern,
    26.             new RouteValueDictionary(defaults),
    27.             new RouteValueDictionary(constraints),
    28.             new RouteValueDictionary(dataTokens));
    29.     }
    30. }

    现在我们在此基础上构建如下这个简单的MVC应用。如代码片段所示，我们调用了AddControllers扩展方法完成了核心服务的注册；调用了MapControllerRoute2扩展方法并注册了一个路径模板为“{controller}/{action}/{id?}”的约定路由。定义的HomeController类型中定义了三个Action方法。采用约定路由的Action方法Foo具有三个输入参数x、y和z，返回根据它们构建的Result对象；Action方法Bar具有相同的参数，但返回一个ValueTask对象，我们通过标注的HttpGetAttribute特性注册了一个路径模板为“bar/{x}/{y}/{z}”的特性路由；Action方法Baz的输入参数类型为Result，返回一个ValueTask对象（具体返回的是一个JsonResult对象）。标注的HttpPostAttribute特性将路由模板设置为“/baz”。

    1. var builder = WebApplication.CreateBuilder(args);
    2. builder.Services.AddControllers2();
    3. var app = builder.Build();
    4. app.MapControllerRoute2(name: "default", pattern: "{controller}/{action}/{id?}");
    5. app.Run();
    6. public class HomeController
    7. {
    8.     public Result Foo(string x, int y, double z) => new Result(x, y, z);
    9.  
    10.     [Microsoft.AspNetCore.Mvc.HttpGet("bar/{x}/{y}/{z}")]
    11.     public ValueTask Bar(string x, int y, double z) => ValueTask.FromResult(new Result(x, y, z));
    12.  
    13.     [Microsoft.AspNetCore.Mvc.HttpPost("/baz")]
    14.     public ValueTask Baz(Result input) => ValueTask.FromResult(new JsonResult(input));
    15. }
    16.  
    17. public record Result(string X, int Y, double Z);

    应用启动后，我们通过路径“/home/foo?x=123&y=456&z=789”访问Action方法Foo，并利用查询字符串指定三个参数值。或者通过路径“/bar/123/456/789”方法ActionBar，并利用路由变量指定三个参数。我们都会得到相同的响应。

    image

    我们使用Fiddler向路径“/baz”发送一个POST请求来访问Action方法Baz，我们将请求的主体内容设置为基于Result类型的JSON字符串，我们提供的IArgumentBinder对象利用发序列化请求主体的形式绑定其参数。由于Action方法最终会返回一个JsonResult，所以响应的内容与请求内容保持一致。

    1. POST http://localhost:5000/baz HTTP/1.1
    2. Host: localhost:5000
    3. Content-Length: 29
    4.  
    5. {"X":"123", "Y":456, "Z":789}
    6.  
    7.  
    8. HTTP/1.1 200 OK
    9. Content-Type: application/json
    10. Date: Fri, 03 Nov 2023 06:12:15 GMT
    11. Server: Kestrel
    12. Content-Length: 27
    13.  
    14. {"X":"123","Y":456,"Z":789}

    文章转载自：Artech

    原文链接：https://www.cnblogs.com/artech/p/mvc-mini-framework.html

  • 相关阅读:
    C++类对象反制机制实现_精简修改版
    算法与数据结构 --- 栈的表示和操作的实现
    【发福利啦！】畅享上百万卡时NPU普惠算力，启智与昇思MindSpore社区联合推出算力支持计划
    阿里云的手机短信验证
    javascript的键值对的问题
    Java线程未捕获异常处理 UncaughtExceptionHandler
    实用电脑软件安利，朋友们快来挖宝
    【Docker】部署环境
    Android学习笔记 71. activity和intent
    快来学习这个高效绘制流程图的方法
  • 原文地址：https://blog.csdn.net/sdgfafg_25/article/details/134306960