Shulou(Shulou.com)06/02 Report--

Today, I will talk to you about how to name routing rules in ASP.NET Core. Many people may not know much about it. In order to make you understand better, the editor has summarized the following for you. I hope you can get something from this article.

For example, put it under / Views.

Views (directory) │ _ ViewImports.cshtml │ _ ViewStart.cshtml │ └─ Home (directory, name of Controller) Index.cshtml (view, Action)

Where Home is a subdirectory, and the Index.cshtml view in the controller Home,Home corresponds to the Action name Index. At this point, the contents of _ ViewStart and _ ViewImports are applied to all views under / Views (such as Index.cshtml).

If it were changed to this way.

Views

├─ Home

│ About.cshtml

│ Index.cshtml

│ _ ViewImports.cshtml

│ _ ViewStart.cshtml

│

└─ Users

AddNew.cshtml

At this point, Views has two subdirectories, Home is one controller and Users is the other. In this case, _ ViewStart and _ ViewImports only work on the views under the Home, but not on the views under the Users directory.

The main purpose of _ ViewStart is to execute before all view files are executed. Generally, we use it to set the Layout property to specify the layout page used (equivalent to the page motherboard). In this way, we do not need to add Layout = "xxxx" on each view. _ ViewImports is mainly used to introduce the namespace to be used (that is, using in C #) so that you don't have to write a bunch of @ using Razor tags in each view.

These two files are contractual, so you should not change its name casually. _ ViewImports can be modified through the ImportsFileName attribute of the RazorTemplateEngineOptions class, but _ ViewStart does not seem to be changed. Lao Zhou sees that the asp.net core source code is written dead, so it is estimated that the file name cannot be changed.

In fact, these two files should not be renamed, and it is useless for you to change the name, anyway, the function is the same, it is better to abide by the agreement, so that people can understand your project. The name of the _ Layout.cshtml file should not be changed if it is not necessary. If your application uses multiple layout views, you may create a subdirectory, and then put _ Layout in each subdirectory, so that the structure is clearer. After all, when you see _ Layout.cshtml, you will understand that it is a motherboard page.

Rule template

We all know that in the Startup.Configure method, the URL path rule is specified in this way.

App.UseMvc (route = > {route.MapRoute ("main", "{controller=Students} / {action=List} / {sid?"); route.MapRoute ("edit_post", "{controller}-{action}");})

You can add K rules, such as the above example, I added two rules.

{controller} and {action} are agreed names to identify Controller and Action, so don't be smart. You need some dead parameters for URL analysis, otherwise, if you give a URL http://dog.org/shopping/pay/500, the application has no idea which segment represents Controller and which represents action.

If the values of controller and action are determined, then the other parameters can be easily analyzed.

If other parameters are optional, you can add a question mark after them, such as {controller} / {action} / {id?}, which means that the value of id is optional.

Among the two rules added by Lao Zhou above, edit_post is actually not very standard, and it is best to use "/" to separate the segments in URL, because "-" is sometimes not allowed. For example, if you cannot use the id parameter in front of it, you cannot write it as {controller}-{action}-{id?}. What if the id contains the character "-"? Unlike "/", this character does not appear after URL Encode.

So use / best, use here-just Lao Zhou deliberately used to demonstrate, URL, there is no need to play tricks, meaningless.

Based on URL routing specified by Attribute

The URL routing specified in the Startup.Configure method works for the entire application, and if you want to specify routing rules for individual controllers or individual Action, consider using the form of Attribute.

Routing rules in the form of attribute are similar to application-level rules, except that at the application level, parameter names are wrapped in curly braces (such as {controller}), while in the Attribute scenario, square braces are used, which can only take two values: [controller] and [action]. Other parameters also use curly braces. For example, [controlloer] / [action] / [id?] Will report an error, you have to change it to [controller] / [action] / {id?}.

RouteAttribute can be used on either a Controller type or a single Action method. Let me give you an example, like this.

[Route ("hello/ [controller] / [action]")]

Public class SomethingController: Controller

{

[Route ("{name?}")]

Public IActionResult SayHi (string name)

{

……

}

}

In the Attribute used for application on the class, you can use such URL: http://localhost:999/hello/something/sayhi. On the SayHi method, Route Attribute is used, an additional parameter name is specified, and it is optional. So it can be merged with Route attribute on the class to: http://localhost:999/hello/something/sayhi/Peter. At this point, the string Peter is passed to the name parameter of the SayHi method, because the name of the parameter is the same as the name of the parameter in Route, both called name. If the parameter name in SayHi is not name, then you need to use FromRouteAttribute. Like this.

[Route ("{name?}")] public IActionResult SayHi ([FromRoute (Name = "name")] string who) {. }

If you want to pass a value of type int to name in URL, you can also restrict it.

[Route ("{name:int}")]

In fact, these constraints correspond to the types under the Microsoft.AspNetCore.Routing.Constraints namespace.

Route Data

Route data is actually a dictionary that stores the key-value pairs of parameters and values in the URL path rules. This is very simple. I'll give you an example, and you'll see.

Let's just use the above example.

[Route ("hello/ [controller] / [action]")]

Public class SomethingController: Controller

{

[Route ("{name?}")]

Public IActionResult SayHi ([FromRoute (Name = "name")] string who)

{

Return Json (RouteData.Values)

}

}

In the SayHi method, we return route data.

After running the application, enter the address: http://localhost/hello/something/sayhi/Tom, and the output is as follows:

I don't have to explain.

Name a route

All of the above are F words, and this section is the theme of this article. Let's look back at the route that Lao Zhou gave an example above.

App.UseMvc (route = > {route.MapRoute ("main", "{controller=Students} / {action=List} / {sid?"); route.MapRoute ("edit_post", "{controller}-{action}");})

Each routing rule has its own name, so why name it? The most direct reason is to uniquely identify each rule. In addition to this factor, we can choose which rule to use in the development process. With name, it is easy to find a rule, just like when you were at school, the teacher called the roll, either the name or the student number.

Attribute-based routing rules can also be named, for example.

[Route ("hello/ [controller] / [action]", Name = "prv")]

So you can name it prv, and you can write it this way.

[Route ("hello/ [controller] / [action]", Name = "[controller] _ [action]")]

It is also possible to generate a unique name with the names of Controller and Action, such as Something_SayHi. But this method is too dynamic and doesn't seem to be easy to manipulate, so it's better to use a fixed name.

To choose to use the specified URL route at development time, you need to add Tag Helper to the Razor page, and the tag helper class can extend some of the functionality of the HTML tag. Add these directives to the page where you need to use tag helper, or uniformly in the _ ViewImports.cshtml page.

@ addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

The format is as follows:

The type is written first (including the namespace name), and the assembly name is written at the end, separated by a comma. It's best to use an asterisk (*) here, which is a wildcard to indicate the introduction of all tag helper types. So fast, one line of code to get things done.

And then you write this in HTML.

Submit

You don't have to look at the other code, just this one sentence is enough:

Asp-route= "edit_post"

It means to use the rule I just defined.

Route.MapRoute ("edit_post", "{controller}-{action}")

Therefore, such a HTML will be generated after running.

1650 words are omitted here

Because the rules I define are in the form of {controller}-{action}, Controller is Students,Action and Editdata, which is Students-Editdata.

So why does it recognize the values of controller and action here? just take a look at my code.

Public class StudentsController: Controller

{

Readonly StudentDBContext m_context

/ / receive dependency injection

Public StudentsController (StudentDBContext c)

{

M_context = c

}

Public IActionResult List ()

{

Var Q = from s in m_context.Students

Orderby s.ID

Select s

Return View (q.ToList ())

}

/ * /

/ / the following methods are used to edit the page

[HttpGet]

Public IActionResult Editdata ([FromRoute (Name = "sid")] int id)

{

Var Q = from s in m_context.Students

Where id = = s.ID

Select s

Student stu = q.FirstOrDefault ()

If (stu = = null)

{

Return Content ("this student cannot be found on Earth.")

}

Return View (stu)

}

[HttpPost]

Public IActionResult Editdata (Student s)

{

If (ModelState.IsValid = = false)

{

Return View (s)

}

M_context.Students.Update (s)

M_context.SaveChanges ()

Return RedirectToAction (nameof (List))

}

}

The overload of the Editdata method is defined, one for the get request and one for the post request, and the form is submitted as post, so it automatically recognizes the names of controller and action.

What if, if it's not the same name, it's easy to do. You use asp-route- to specify the values of each parameter. Like this.

Just follow the asp-route- directly with the name of the routing rule parameter.

After reading the above, do you have any further understanding of how to name routing rules in ASP.NET Core? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.