ASP.NET Core MVC konfiguriert das globale Routing-Präfix

ASP.NET Core MVC konfiguriert globales Routing-Präfix

Vorwort

Hallo zusammen, heute werde ich euch eine neue Funktion von ASP.NET Core MVC vorstellen, nämlich Globales Routing Unified-Präfix hinzufügen. Streng genommen handelt es sich nicht um eine neue Funktion, sondern nur um Core MVC.

Anwendungshintergrund

Ich weiß nicht, ob Sie jemals auf dieses Szenario gestoßen sind, wenn Sie Web-API-Anwendungen erstellen, das heißt, alle Schnittstellen beginnen mit /api, was wir tun Die API Die Schnittstellenanforderungsadresse lautet wie folgt:

http://www.example.com/api/order/333

oder eine solche Anforderung

http:/ /www.example.com/api/v2/order/333

Wenn wir diese Anforderung in der Vergangenheit erfüllen wollten, konnten wir eine [Route("/api /order")] hinzufügen. , dann durchsucht das MVC-Framework Ihre Routing-Tabelle, um Anfragen wie /api/order zu entsprechen.

Aber für die zweite Anforderung mit einer Versionsnummer war die Routendefinition des ursprünglichen Controllers [Route("/api/v1/order")]. Jetzt muss sie auf v2 aktualisiert werden, und zwar dort Es gibt Hunderte weitere Die Schnittstelle muss einzeln geändert werden, was zu Verwirrung führen kann.

Jetzt gibt es eine einfachere und elegantere Möglichkeit, ein globales Präfix-Routing-Tag auf einheitliche Weise hinzuzufügen.

IApplicationModelConvention-Schnittstelle

Zuerst müssen wir die IApplicationModelConvention-Schnittstelle verwenden, die sich unter dem Namespace Microsoft.AspNetCore.Mvc.ApplicationModels befindet.

public interface IApplicationModelConvention
{
 void Apply(ApplicationModel application);
}

Wir wissen, dass das MVC-Framework einige Konventionen hat, daher wird diese Schnittstelle hauptsächlich zum Anpassen einiger MVC-Konventionen verwendet. Wir können einige angeben Konventionen. Sie können sehen, dass die Schnittstelle eine Apply-Methode bereitstellt, die über ein ApplicationModel-Objekt verfügt. Wir können dieses Objekt verwenden, um das zu ändern, was wir benötigen. Das MVC-Framework selbst wird diese Schnittstelle beim Start in Services einfügen, sodass wir diese Schnittstelle nur implementieren müssen kann leicht konfiguriert werden.

Dann schauen wir uns an, was das ApplicationModel-Objekt hat:

public class ApplicationModel : IPropertyModel, IFilterModel, IApiExplorerModel
{
 public ApiExplorerModel ApiExplorer { get; set; }
 public IList<ControllerModel> Controllers { get; }
 public IList<IFilterMetadata> Filters { get; }
 
 public IDictionary<object, object> Properties { get; }
}

Sie können sehen, dass es ApiExplorer, Controller, Filter, Eigenschaften und andere Eigenschaften gibt .

ApiExplorerModel: Konfiguriert hauptsächlich einige Dinge des Standard-MVC-API-Explorers, einschließlich API-Beschreibungsinformationen, Gruppeninformationen, Sichtbarkeit usw.

ControllerModel: Bezieht sich hauptsächlich auf die Standardkonvention des Comtrollers. Darin sind viele Dinge enthalten, daher werde ich sie nicht einzeln vorstellen. Wir werden eines der darin enthaltenen Dinge später konfigurieren.

IFilterMetadata: Leere Schnittstelle, hauptsächlich als Markierung verwendet.

Eine weitere Sache, die ich Ihnen sagen muss, ist, dass Sie sehen können, dass die Controllers-Eigenschaft oben ein IList ist, was bedeutet, dass diese Liste die Informationen aller Controller in Ihrem Programm aufzeichnet. Sie können es für einen bestimmten Teil oder einen Controller durch Durchlaufen festlegen, einschließlich der Informationen von Aktionen im Controller. Wir können diese Funktion verwenden, um das MVC-Framework sehr flexibel zu transformieren, oder?

Als nächstes werden wir diese Funktion nutzen, um unser heutiges Thema umzusetzen. Vielen Dank für Ihren Daumen hoch~ :)

Fügen Sie ein einheitliches Präfix für globales Routing hinzu

Kein Unsinn mehr, gehen Sie direkt zum Code, alles, was Sie sagen möchten, ist im Code:

//定义个类RouteConvention，来实现 IApplicationModelConvention 接口
public class RouteConvention : IApplicationModelConvention
{
 private readonly AttributeRouteModel _centralPrefix;
 
 public RouteConvention(IRouteTemplateProvider routeTemplateProvider)
 {
  _centralPrefix = new AttributeRouteModel(routeTemplateProvider);
 }
 
 //接口的Apply方法
 public void Apply(ApplicationModel application)
 {
  //遍历所有的 Controller
  foreach (var controller in application.Controllers)
  {
   // 已经标记了 RouteAttribute 的 Controller
   var matchedSelectors = controller.Selectors.Where(x => x.AttributeRouteModel != null).ToList();
   if (matchedSelectors.Any())
   {
    foreach (var selectorModel in matchedSelectors)
    {
     // 在 当前路由上 再 添加一个 路由前缀
     selectorModel.AttributeRouteModel = AttributeRouteModel.CombineAttributeRouteModel(_centralPrefix,
      selectorModel.AttributeRouteModel);
    }
   }
 
   // 没有标记 RouteAttribute 的 Controller
   var unmatchedSelectors = controller.Selectors.Where(x => x.AttributeRouteModel == null).ToList();
   if (unmatchedSelectors.Any())
   {
    foreach (var selectorModel in unmatchedSelectors)
    {
     // 添加一个 路由前缀
     selectorModel.AttributeRouteModel = _centralPrefix;
    }
   }
  }
 }
}

Dann können wir beginnen, die von uns definierte Klasse zu verwenden.

public static class MvcOptionsExtensions
{
 public static void UseCentralRoutePrefix(this MvcOptions opts, IRouteTemplateProvider routeAttribute)
 {
  // 添加我们自定义 实现IApplicationModelConvention的RouteConvention
  opts.Conventions.Insert(0, new RouteConvention(routeAttribute));
 }
}

Zum Schluss fügen Sie in der Datei „Startup.cs“ einfach die obige Erweiterungsmethode hinzu.

public class Startup
{
 public Startup(IHostingEnvironment env)
 {
  //...
 }
 
 public void ConfigureServices(IServiceCollection services)
 {
  //...
   
  services.AddMvc(opt =>
  {
   // 路由参数在此处仍然是有效的，比如添加一个版本号
   opt.UseCentralRoutePrefix(new RouteAttribute("api/v{version}"));
  });
 }
 
 public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
 {
  //...
   
  app.UseMvc();
 }
}

Unter anderem ist opt.UseCentralRoutePrefix die oben definierte Erweiterungsmethode. Die Routing-Parameter können hier beispielsweise weiterhin verwendet werden kann Ihnen die Schnittstelle geben so etwas wie eine Versionsnummer. Danach wird das RoteAttribute aller Ihrer Controller mit diesem Präfix hinzugefügt, wodurch die ursprüngliche Anforderung an die Versionsnummer perfekt gelöst wird. Sie sehen ungefähr so ​​aus:

[Route("order")]
public class OrderController : Controller
{
 // 路由地址 : /api/v{version}/order/details/{id}
 [Route("details/{id}")]
 public string GetById(int id, int version)
 {
  //上面是可以接收到版本号的，返回 version 和 id
  return $"other resource: {id}, version: {version}";
 }
}
 
public class ItemController : Controller
{
 // 路由地址： /api/v{version}/item/{id}
 [Route("item/{id}")]
 public string GetById(int id, int version)
 {
  //上面是可以接收到版本号的，返回 version 和 id
  return $"item: {id}, version: {version}";
 }
}

Zusammenfassung

Die fett gedruckten Worte oben, ich hoffe, dass jeder dieses Beispiel verstehen und verwenden kann. Es ist einfach In bestimmten Projekten gibt es verschiedene normale oder ungewöhnliche Anforderungen. Tatsächlich gibt es noch viel mehr über das MVC-Framework zu lernen , Skalierbarkeit und andere Dinge müssen alle langsam verstanden werden. Wenn Sie sich für ASP.NET Core interessieren, können Sie mir folgen. Ich werde regelmäßig einige meiner Lernergebnisse in meinem Blog teilen.

Ich hoffe, dieser Artikel kann allen helfen. Vielen Dank für Ihre Unterstützung dieser Website!

Weitere Artikel zum Konfigurieren des globalen Routing-Präfixes mit ASP.NET Core MVC finden Sie auf der chinesischen PHP-Website!