How to use endpoint routing in ASP.NET Core 3.0 MVC
ASP.NET Core MVC is the .NET Core match of the ASP.NET MVC framework. You can take gain of ASP.NET Core MVC to build cross-platform_ scalable_ high-accomplishment web applications and APIs using the Model-View-Controller design model. ASP.NET Core takes gain of routing to map incoming requests to relative controller actions.
You can acquire the basics of routing in ASP.NET Core from my earlier article_ “Demystified: Routing in ASP.NET Core .” This article presents a debateion of how we can use endpoint routing in ASP.NET Core 3.0 MVC.
Endpoint routing is a component newly introduced in ASP.NET Core that empowers you to prepare routing information to middleware in the request processing pipeline. Before the induction of endpoint routing_ routing separation in ASP.NET Core MVC was performed at the end of the request processing pipeline. As a result_ way information such as which action order needs to be executed was mysterious to any middleware processing a request precedently the MVC middleware in the request processing pipeline. Incidentally_ endpoint routing is useful as part of ASP.NET 3.0 and later versions.
Endpoint routing matches HTTP requests to endpoints soon in the middleware pipeline instead of at the end. This allows middleware later in the pipeline to approach the resolved endpoint and adduce additional processing. In other words_ endpoint routing decouples the way matching and endpoint dispatching functions_ giving you the flexibility to combine different middleware MVC_ CORS_ Razor Pages_ Blazor_ etc. in your applications.
To work with the code samples prepared in this article_ you should have Visual Studio 2019 installed in your order. If you dont have a copy of it_ you can download Visual Studio 2019 here .
Create an ASP.NET Core MVC project First off_ lets form an ASP.NET Core project in Visual Studio. Assuming Visual Studio 2019 is installed in your order_ pursue the steps outlined under to form a new ASP.NET Core MVC project in Visual Studio.
<_aside>
Launch the Visual Studio IDE.<_li>
Click on “Create new project.”<_li>
In the “Create new project” window_ select “ASP.NET Core Web Application” from the list of templates displayed.<_li>
Click Next.<_li>
In the “Configure your new project” window shown next_ particularize the name and location for the new project.<_li>
Click Create.<_li>
In the “Create a New ASP.NET Core Web Application” window_ select .NET Core as the runtime and ASP.NET Core 3.0 or later from the drop-down list at the top. <_li>
Select “Web Application Model-View-Controller” as the project template.<_li>
Ensure that the check boxes “Enable Docker Support” and “Configure for HTTPS” are unchecked as we wont be using those components here.<_li>
Ensure that Authentication is set as “No Authentication” as we wont be using authentication whichever.<_li>
Click Create.<_li>
<_ol>This will form a new ASP.NET Core project in Visual Studio. Well use this project to instrument endpoint routing in the posterior sections of this article.
Create a new controller in ASP.NET Core 3.0 MVC In the Solution Explorer Window_ select the Controllers folder in the project_ right-click and then click on Add-gt;Controller… to form a new controller. Specify the name of the controller class as AuthorController. Next_ restore the code of the AuthorController class with the pursueing code.
<_aside>[Route"api_[controller]"] [ApiController] open class AuthorController : ControllerBase { readonly Repository repository _ new Repository; [HttpGet] open ActionResult GetAuthors { var records _ repository.GetAllAuthors; recur Okrecords; } }<_pre>Well use the AuthorController in the posterior sections of this article.
Understand routing in ASP.NET Core Routing is a component that exposes endpoints and matches incoming HTTP requests to your controllers action orders. The routing middleware pertaining to the Microsoft.AspNetCore.Routing namespace is responsible for handling requests and responses_ inspecting requests and matching them to endpoints_ and even modifying the request and response messages that flow through the request processing pipeline.
Convention routing vs. attribute routing You can particularize routing in your action orders in two different ways — assemblage-based routing and attribute-based routing.
The pursueing code snippet illustrates how you can use assemblage routing in the Configure order of the Startup class.
<_aside>app.UseMvcways _gt;{ ways.MapRoute name: "lapse"_ template: "{controller_Author}_{action_GetAuthors}_{id?}";};<_pre>When using attribute-based routing you would mention way on your controller or the action order. You can mark multiple ways for the same action order. Here is an sample that illustrates this.
open class AuthorController : Controller{ [Route""] [Route"Home"] [Route"Home_Index"] open IActionResult Index { recur View; } [Route"Home_GetAuthor_{id:int}"] open IActionResult GetAuthorint id { ViewBag.Id _ id; recur View; }}<_pre>Route determinations in ASP.NET Core 3.0 MVC When you form a new ASP.NET Core 3.0 MVC application_ a lapse way will be formd for you by Visual Studio. This is how it would look.
app.UseEndpointsendpoints _gt;{ endpoints.MapControllerRoute name: "lapse"_ model: "{controller_Home}_{action_Index}_{id?}";}<_pre>The way determination shown here consists of two parameters — the name of the way and the way model. This way will match the pursueing URLs.
_Home_Index_Author_Index_Author_Index_12<_pre>UseRouting vs. UseEndpoints in ASP.NET Core 3.0 MVC Routing takes gain of a pair of middleware components that are registered using the UseRouting and UseEndpoints extension orders. While the preceding is used to match a request to an endpoint_ the latter is used to execute a matched endpoint.
Note that the UseRouting middleware should be configured forward of all other middleware including authentication_ authorization_ and any manner middleware. By opposition_ the UseEndpoints middleware should be configured at the end. The pursueing code snippet illustrates this.
open void ConfigureIApplicationBuilder app_ IWebHostEnvironment env { if env.IsDevelopment { app.UseDeveloperExceptionPage; } else { app.UseExceptionHandler"_Home_Error"; } app.UseStaticFiles; app.UseRouting; app.UseAuthorization; app.UseEndpointsendpoints _gt; { endpoints.MapControllerRoute name: "lapse"_ model: "{controller_Author}_{action_GetAuthor}_{id?}"; }; }<_pre>If you want to check the way metadata at runtime_ you can use the pursueing code and debug it in Visual Studio.
app.Useasync tenor_ next _gt;{ var endPoint _ tenor.GetEndpoint; var ways _ tenor.Request.RouteValues;};<_pre>Configure routing in ASP.NET Core 3.0 MVC You can set up routing in your ASP.NET Core 3.0 MVC application easily. For this you would need to make a couple of changes to the Startup class. First off_ you should call the AddRazorPages order as shown under.
open void ConfigureServicesIServiceCollection labors{ labors.AddRazorPages;}<_pre>Next_ you should call the MapRazorPages order as shown under. This order when named will add the Razor Pages labors_ options_ and assemblages to the pipeline.
open void ConfigureIApplicationBuilder app_ IWebHostEnvironment env { __Usual code app.UseEndpointsendpoints _gt; { endpoints.MapRazorPages; endpoints.MapControllerRoute name: "lapse"_ model: "{controller_Author}_ {action_GetAuthor}_{id?}"; }; }<_pre>Use named ways in ASP.NET Core 3.0 MVC Note that you can particularize a name for a way so that you can use multiple ways having the same parameters. Such ways are known as named ways. The pursueing code snippet illustrates how named ways can be used.
app.UseEndpointsendpoints _gt;{ endpoints.MapControllerRoute name: "lapse"_ model: "{controller_Author}_{action_GetAuthors}_{id?}";}<_pre>Set way lapses in ASP.NET Core 3.0 MVC You can also explicitly set way lapses as shown in the code snippet under.
endpoints.MapControllerRoute name: "lapse"_ model: "{controller}_{action}_{id?}"_ lapses: new {controller _ "Home"_ action _ "Index"};<_pre>Use MapRazorPages in ASP.NET Core 3.0 MVC You can take gain of the MapRazorPages extension order to empower routing for your Razor view pages. The pursueing code snippet shows how this can be achieved.
app.UseEndpointsendpoints _gt;{ endpoints.MapRazorPages;};<_pre>Use mixed routing in ASP.NET Core 3.0 MVC Note that you can use attribute-based routing for some controllers and actions and assemblage-based routing on other controllers and action orders. Although it is fully strong to use both_ it should be noted that you cannot have attribute-based routing and assemblage-based routing in the same action order.
ASP.NET 3.0 gives us an extensible and modular framework for working with endpoints_ URLs_ and middleware. Ill debate routing in more depth in a forthcoming article here. Well explore the advanced routing components in ASP.NET Core 3.0 such as way templates_ way constraints_ manner way constraints_ and more.
