ASP.NET Core 3 中的自定义路由

您是否曾经想停止使用Microsoft的内置URL路由并将其替换为自己的实现？在本教程中，我将向您展示如何在ASP.NET Core 3 Web API中实现自定义路由。这可以通过用我们自己的Microsoft替换请求管道中间件来实现。在本教程结束时，我们将使用以下路由语法提供一个具有两个端点的有效Web Api：

 

这篇文章将介绍以下内容：

1. 先决条件
2. 创建ExampleController
3. 创建RouteSettings
4. 创建RouteManager
5. 创建EndpointActivator
6. 创建CustomRoutingMiddleware
7. 注册中间件并测试

 

先决条件

在开始本教程之前，您应该熟悉反射和ASP.NET Core Web API请求管道。

首先，创建一个ASP.NET Core 3 Web API项目并删除Startup.ConfigureServices和Startup.Configure中的方法主体。

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }
 
    public IConfiguration Configuration { get; }
 
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
 
    }
 
    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
 
    }
}

 

创建控制器

创建控制器很简单-我们将有两个端点。一个不接受任何输入并返回一个字符串，另一个接受一个请求对象并重复该字符串x次。

public class ExampleController
{
    public async Task<string> Marco()
    {
        return await Task.FromResult("Polo");
    }
 
    public async Task<string> Echo(EchoRequest echoRequest)
    {
        StringBuilder echoBuilder = new StringBuilder();
 
        for(int i = 0; i < echoRequest.EchoCount; i++)
        {
            echoBuilder.Append($"{ echoRequest.Content}...");
        }
 
        return await Task.FromResult(echoBuilder.ToString());
    }
}
 
public class EchoRequest
{
    public string Content { get; set; }
    public int EchoCount { get; set; }
}

 

创建RouteSettings

RouteSettings只是一个模型类，用于存储每个路由的设置。

public class RouteSettings
{
    public string URL { get; set; }
    public string Action { get; set; }
    public Type Controller { get; set; }
    public string Endpoint { get; set; }
}

 

创建RouteManager

RouteManager承担两项职责-添加路由和解析URL。

添加路由时，该类将使用反射来获取设置中描述的端点的MethodInfo，然后使用“（Action）（URL）”作为路由键添加路由。

要解析URL，RouteManager会根据给定的路由键返回MethodInfo。

public class RouteManager
{
    private IDictionary<string, MethodInfo> _routes = new Dictionary<string, MethodInfo>();
 
    public RouteManager AddRoute(Action<RouteSettings> setup)
    {
        var routeSettings = new RouteSettings();
        setup(routeSettings);
 
        string routeKey = $"{routeSettings.Action} {routeSettings.URL}";
 
        var endpointMethod = Assembly.GetExecutingAssembly()
            .GetTypes()
            .FirstOrDefault(type => type.Equals(routeSettings.Controller))
            .GetMethod(routeSettings.Endpoint);
 
        _routes.Add(routeKey, endpointMethod);
 
        return this;
    }
 
    public MethodInfo Resolve(string action, string url)
    {
        if (url.StartsWith("/"))
        {
            url = url.Remove(0, 1);
        }
 
        string routeKey = $"{action} {url}";
 
        if(_routes.TryGetValue(routeKey, out MethodInfo methodEndpoint))
        {
            return methodEndpoint;
        }
 
        throw new Exception($"No matching route for {routeKey}");
    }
}

 

创建EndpointActivator

EndPointActivator创建Controller的实例，然后执行给定的Endpoint。如果端点需要参数，例如ExampleController.Echo，则通过反序列化请求正文来初始化参数。

 

public class EndpointActivator
{
    public async Task<object> ActivateAsync(MethodInfo endpointMethod, string requestBody)
    {
        // create an instance of the controller
        var controllerType = endpointMethod.DeclaringType;
        var controller = Activator.CreateInstance(controllerType);
 
        var endpointParameter = endpointMethod.GetParameters().FirstOrDefault();
 
        if (endpointParameter is null)
        {
            var endpointResponse = endpointMethod.Invoke(controller, null);
            var response = await IfAsync(endpointResponse);
            return response;
        }
        else
        {
            var requestBodyParameter = DeserializeRequestBody(requestBody, endpointParameter);
            var endpointResponse = endpointMethod.Invoke(controller, new object[] { requestBodyParameter });
            var response = await IfAsync(endpointResponse);
            return response;
        }
    }
 
    private static object DeserializeRequestBody(string requestBody, ParameterInfo endpointParameter)
    {
        var deserializedParamter = JsonConvert.DeserializeObject(requestBody, endpointParameter.ParameterType);
 
        if (deserializedParamter is null)
        {
            throw new ArgumentException($"Unable to deserialze request body to type {endpointParameter.ParameterType.Name}");
        }
 
        return deserializedParamter;
    }
 
    private static async Task<object> IfAsync(object endpointResponse)
    {
        var responseTask = endpointResponse as Task;
 
        if (responseTask is null)
        {
            return endpointResponse;
        }
 
        await responseTask;
 
        var responseTaskResult = responseTask.GetType()
            .GetProperty("Result")
            .GetValue(responseTask);
 
        return responseTaskResult;
    }
}

 

创建CustomRoutingMiddleware

CustomRoutingMiddleware汇集了RouteManager和EndpointActivator来处理从请求管道传递的HttpContext对象。它还公开了一个IApplicationBuilder扩展方法，该方法将自身注册到应用程序的请求管道中并返回RouteManager实例，以便我们可以添加路由。

public static class CustomRoutingMiddleware
{
    private static RouteManager _routeManager = new RouteManager();
    private static EndpointActivator _endpointActivator = new EndpointActivator();
 
    public static RouteManager UseCustomRouting(this IApplicationBuilder app)
    {
        // Add TryProcess() to request pipeline
        app.Use(async (context, next) =>
        {
            await TryProcess(context);
        });
 
        return _routeManager;
    }
 
    public static async Task TryProcess(HttpContext context)
    {
        try
        {
            // get endpoint method
            var endpointMethod = _routeManager.Resolve(context.Request.Method, context.Request.Path);
 
            // read request body
            string requestBody = await new StreamReader(context.Request.Body, Encoding.UTF8).ReadToEndAsync();
 
            // activate the endpoint
            var response = await _endpointActivator.ActivateAsync(endpointMethod, requestBody);
 
            // serialize the response
            var serializedResponse = JsonConvert.SerializeObject(response, Formatting.Indented);
 
            // return response to client
            await context.Response.WriteAsync(serializedResponse);
        }
        catch(Exception error)
        {
            context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
            await context.Response.WriteAsync(error.Message);
        }
    }
}

 

注册中间件并测试

现在，我们要做的就是调用IApplicationBuilder.UseCustomRouting并将路由添加到Startup.Configure方法中。

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }
 
    public IConfiguration Configuration { get; }
 
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
 
    }
 
    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseCustomRouting()
            .AddRoute(settings =>
            {
                settings.URL = "example/marco";
                settings.Action = "GET";
                settings.Controller = typeof(ExampleController);
                settings.Endpoint = nameof(ExampleController.Marco);
            })
            .AddRoute(settings =>
            {
                settings.URL = "example/echo";
                settings.Action = "POST";
                settings.Controller = typeof(ExampleController);
                settings.Endpoint = nameof(ExampleController.Echo);
            });
    }
}

我将使用Postman来测试API。

---

---