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。

---

---