C#/.net>> dotnet-core-endpoints-routing>> 返回
项目作者： sulmar

项目描述 ：
Przykład definiowania tras za pomocą endpoints
高级语言： C#
项目地址: git://github.com/sulmar/dotnet-core-endpoints-routing.git
创建时间： 2020-02-07T09:14:19Z
项目社区：https://github.com/sulmar/dotnet-core-endpoints-routing
开源协议：
下载


Endpoints w .NET Core

Wprowadzenie

W .NET Core 2.2 wprowadzony został mechanizm endpoints a w .NET Core 3 stał się zalecanym sposobem mapowania żądań.
Korzystają z niego chociażby technologie MVC i SignalR.

Czyli obecnie zamiast:

  1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2. {
  3.   app.UseMvc();
  4. }

Piszemy:

  1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2. {
  3.   app.UseEndpoints(endpoints =>
  4.    {
  5.        endpoints.MapControllerRoute(
  6.            name: "default",
  7.            pattern: "{controller=Home}/{action=Index}/{id?}");
  8.    });
  9.  }

Dlaczego to zostało zmienione?

Otóż wcześniej każdy middleware miał własny sposób mapowania ścieżek, na przykład UseMvc(), UseSignalR()
To powodowało, że każdy framework był konfigurowany w nieco w inny sposób.

Dzięki endpoints zostało to zunifikowane i teraz każdy programista może skorzystać z tego mechanizmu podczas tworzenia własnej warstwy pośredniej (middleware).

W takim razie w jaki sposób zastosować to we własnym rozwiązaniu?

Wymaganie

Chcemy utworzyć własny dasboard, który będzie podpinany pod url /mydashoard

  1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2. {
  3.     app.UseRouting();
  5.     app.UseEndpoints(endpoints =>
  6.     {
  7.         endpoints.MapMyDashboard("/mydashboard");
  8.      }
  9.  }

Warstwa pośrednia (middleware)

Na początek utwórzmy warstwę pośrednią

  1.  public class MyDashboardMiddleware
  2.     {
  3.         private readonly RequestDelegate next;
  5.         public MyDashboardMiddleware(RequestDelegate next)
  6.         {
  7.             this.next = next;     
  8.         }
  10.         public async Task InvokeAsync(HttpContext context)
  11.         {
  12.             string title = "My dashboard";
  13.             string content = "Hello World!";
  15.             context.Response.StatusCode = 200;
  16.             context.Response.ContentType = "text/html";
  17.             await context.Response.WriteAsync($@"<html><head><title>{title}</title><head><body>{content}</body></html>");
  18.         }
  19.     }

Użycie

Teraz możemy podpiąć w klasie Startup z użyciem endpoints:

  1.  public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2.  {
  3.      if (env.IsDevelopment())
  4.      {
  5.          app.UseDeveloperExceptionPage();
  6.      }
  8.      app.UseRouting();
  10.      app.UseEndpoints(endpoints =>
  11.      {
  12.          endpoints.Map("/", async context => await context.Response.WriteAsync("Hello World!"));
  14.          endpoints.Map("/mydashboard", endpoints.CreateApplicationBuilder()
  15.              .UseMiddleware<MyDashboardMiddleware>()
  16.              .Build());
  17.             }

Utworzenie metody rozszerzającej

W celu ułatwienia korzystania z naszej warstwy utworzymy metodę rozszerzającą MapMyDashboard()

  1.  public static class MyEndpointRouteBuilderExtensions
  2.  {
  3.      public static IEndpointConventionBuilder MapMyDashboard(
  4.       this IEndpointRouteBuilder endpoints,
  5.       string pattern = "/dashboard")
  6.      {
  7.          var app = endpoints.CreateApplicationBuilder();
  9.          var pipeline = app
  10.               .UsePathBase(pattern)
  11.               .UseMiddleware<MyDashboardMiddleware>()
  12.               .Build();
  14.          // Glob patterns
  15.          // https://docs.microsoft.com/pl-pl/aspnet/core/fundamentals/file-providers?view=aspnetcore-3.1
  16.          return endpoints.Map(pattern + "/{**path}", pipeline);
  18.      }
  19.    }

Zastosowanie metody MapMyDashboard()

  1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2. {
  3.     app.UseRouting();
  5.     app.UseEndpoints(endpoints =>
  6.     {
  7.         endpoints.Map("/", async context => await context.Response.WriteAsync("Hello World!"));
  9.         endpoints.MapMyDashboard("/mydashboard");
  10.      }
  11.  }

Konfiguracja

W jaki sposób przekazać opcje na wzór MapHub?

Opcje

Tworzymy klasę opcji:

  1. public class MyDashboardOptions
  2. {
  3.      public string DashboardTitle { get; set; }
  4. }

Warstwa pośrednia (middleware)

Przekazujemy ją poprzez konstruktor

  1. public class MyDashboardMiddleware
  2.     {
  3.         private readonly RequestDelegate next;
  4.         private readonly MyDashboardOptions options;
  6.         public MyDashboardMiddleware(RequestDelegate next, MyDashboardOptions options)
  7.         {
  8.             this.next = next;
  9.             this.options = options;
  10.         }
  12.         public async Task InvokeAsync(HttpContext context)
  13.         {
  14.             string title = options.DashboardTitle;
  15.             string content = "Hello World!";
  17.             context.Response.StatusCode = 200;
  18.             context.Response.ContentType = "text/html";
  19.             await context.Response.WriteAsync($@"<html><head><title>{title}</title><head><body>{content}</body></html>");
  20.         }
  21.     }

Metoda rozszerzająca

Dodajemy parametr Action gdzie T to nasza klasa z opcjami:

  1. public static class MyEndpointRouteBuilderExtensions
  2.     {
  3.         public static IEndpointConventionBuilder MapMyDashboard(
  4.          this IEndpointRouteBuilder endpoints,
  5.          string pattern = "/dashboard",
  6.          Action<MyDashboardOptions> configureOptions = null
  7.          )
  8.         {
  9.             var app = endpoints.CreateApplicationBuilder();
  11.             var options = new MyDashboardOptions();
  12.             configureOptions?.Invoke(options);
  14.             var pipeline = app
  15.                  .UsePathBase(pattern)
  16.                  .UseMiddleware<MyDashboardMiddleware>(options)
  17.                  .Build();
  19.             // Glob patterns
  20.             // https://docs.microsoft.com/pl-pl/aspnet/core/fundamentals/file-providers?view=aspnetcore-3.1
  21.             return endpoints.Map(pattern + "/{**path}", pipeline);
  23.         }

Użycie

  1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  2. {
  3.     if (env.IsDevelopment())
  4.     {
  5.         app.UseDeveloperExceptionPage();
  6.     }
  8.     app.UseRouting();
  10.     app.UseEndpoints(endpoints =>
  11.     {
  12.       endpoints.MapMyDashboard("/mydashboard", options => options.DashboardTitle = "My dashboard");
  13.     }
  14. }

Wstrzykiwanie zależności (Dependency Injections)

Utworzenie usługi

  1. public interface IContentService
  2.  {
  3.      string Get();
  4.  }
  6.   public class MyContentService : IContentService
  7.     {
  8.         public string Get()
  9.         {
  10.             return "Hello Dashboard!";
  11.         }
  12.     }
  14.     public static class MyServiceCollectionExtensions
  15.     {
  16.         public static IServiceCollection AddMyContentService([NotNull] this IServiceCollection services)
  17.         {
  18.             services.AddTransient<IContentService, MyContentService>();
  20.             return services;
  21.         }
  22.     }

Utworzenie warstwy pośredniej (middleware)

  1.   public class MyDashboardMiddleware
  2.     {
  3.         private readonly RequestDelegate next;
  4.         private readonly MyDashboardOptions options;
  5.         private readonly IContentService contentService;
  7.         public MyDashboardMiddleware(RequestDelegate next, MyDashboardOptions options, IContentService contentService)
  8.         {
  9.             this.next = next;
  10.             this.options = options;
  11.             this.contentService = contentService;
  12.         }
  14.         public async Task InvokeAsync(HttpContext context)
  15.         {
  16.             string content = contentService.Get();
  18.             context.Response.StatusCode = 200;
  19.             context.Response.ContentType = "text/html";
  20.             await context.Response.WriteAsync($@"<html><head><title>{options.DashboardTitle}</title><head><body>{content}</body></html>");
  21.         }
  22.     }

Utworzenie metody rozszerzającej

  1.   public static class MyServiceCollectionExtensions
  2.     {
  3.         public static IServiceCollection AddMyContentService([NotNull] this IServiceCollection services)
  4.         {
  5.             services.AddTransient<IContentService, MyContentService>();
  7.             return services;
  8.         }
  9.     }

Użycie

  1. public void ConfigureServices(IServiceCollection services)
  2.  {
  3.      services.AddMyContentService();
  4.  }

Podsumowanie

Przedstawiony kod można potraktować jako szablon do tworzenia własnych rozwiązań.

Powstał w oparciu o analizę kodu źródłowego Signal-R
https://github.com/dotnet/aspnetcore/tree/master/src/SignalR/server/SignalR/src
a w szczególności klasy
https://github.com/dotnet/aspnetcore/blob/master/src/SignalR/server/SignalR/src/HubEndpointRouteBuilderExtensions.cs