ASP.Net Core

Tutorials – ASP.Net Core

Chapter 4: Routing and URL Patterns

In our journey through ASP.NET Core, we have already explored the basics of creating controllers and views in Chapter 3. Now, it’s time to take a deeper dive into this essential aspect of web application development. In Chapter 4, we will delve further into controllers and views, learning advanced techniques and best practices for building robust and interactive web applications.

4.1 Advanced Controller Concepts

In Chapter 3, we introduced controllers as the backbone of ASP.NET Core applications. Controllers handle incoming HTTP requests, process data, and return responses. Now, let’s explore some advanced controller concepts that will enhance your ability to create feature-rich web applications.

4.1.1 Attribute Routing

In ASP.NET Core, you can define routes for your controller actions using attribute-based routing. Attribute routing provides fine-grained control over the URIs that map to specific actions. This is particularly useful when you need custom route patterns or want to define route parameters.

Let’s look at an example of attribute routing:

[Route("api/[controller]")] public class ProductsController : Controller { [HttpGet] public IActionResult Get() { // Retrieve and return a list of products. }

[HttpGet(“{id}”)]
public IActionResult GetById(int id)
{
// Retrieve and return a specific product by ID.
}

[HttpPost]
public IActionResult Create([FromBody] Product product)
{
// Create a new product.
}

[HttpPut(“{id}”)]
public IActionResult Update(int id, [FromBody] Product product)
{
// Update an existing product by ID.
}

[HttpDelete("{id}")] public IActionResult Delete(int id) { // Delete a product by ID. } }

In this example, the [Route] attribute is used to specify the route for the ProductsController. Each action method also has its own route defined using attributes like [HttpGet], [HttpPost], and [HttpPut]. This approach allows for clear and explicit routing configurations.

4.1.2 Action Filters

Action filters are a powerful mechanism in ASP.NET Core that allow you to add pre-processing or post-processing logic to controller actions. They are attributes that you can apply to controller actions to modify the behavior of those actions.

Some common use cases for action filters include:

Authentication: Verify if a user is authenticated before allowing access to an action.
Authorization: Check if a user has the required permissions to execute an action.
Logging: Log information before and after action execution.
Caching: Cache the output of an action to improve performance.

Here’s an example of applying an action filter for authorization:

[Authorize]
public IActionResult SecureAction()
{
    // This action is accessible only to authenticated users.
}

ASP.NET Core provides built-in action filters like [Authorize] and [AllowAnonymous], but you can also create custom action filters to meet specific requirements.

4.1.3 Dependency Injection in Controllers

Dependency injection (DI) is a fundamental concept in ASP.NET Core that allows you to inject dependencies, such as services and repositories, into your controllers. DI promotes a modular and testable code structure by decoupling the controller from the concrete implementations of its dependencies.

To use dependency injection in controllers, you can simply include the required dependency as a parameter in the controller’s constructor:

public class ProductsController : Controller { private readonly IProductService _productService;

public ProductsController(IProductService productService)
{
_productService = productService;
}

// Controller actions can now use _productService to interact with products. }

In this example, IProductService is injected into the ProductsController, allowing the controller to interact with the product-related functionality without being tightly coupled to a specific implementation.

4.1.4 Model Binding

Model binding is a process where data from various sources (e.g., query strings, form fields, route values) is automatically mapped to parameters of a controller action. ASP.NET Core’s model binding system simplifies the extraction of data from HTTP requests and makes it available for processing in your actions.

For instance, consider a form submission with fields for Name and Price. You can create a controller action like this:

[HttpPost]
public IActionResult CreateProduct(string name, decimal price)
{
    // Use 'name' and 'price' in creating a new product.
}

ASP.NET Core will automatically bind the values from the form fields to the name and price parameters of the CreateProduct action.

Model binding supports complex types as well. You can create a model class and bind it to an action parameter:

[HttpPost]
public IActionResult CreateProduct([FromBody] Product product)
{
    // Use 'product' to create a new product.
}

Here, the Product class is used as a model to capture data from the request body in a JSON format.

4.2 Advanced View Techniques

In the previous chapter, we introduced the basics of creating views using Razor syntax. In this section, we’ll explore advanced view techniques to make your web application’s user interface more dynamic and responsive.

4.2.1 Partial Views

Partial views are reusable components of a view that can be rendered independently. They are a way to break down the user interface into smaller, modular parts, making it easier to manage and maintain your views.

For example, you might have a navigation menu that is shared across multiple pages of your application. Instead of duplicating the menu code in each view, you can create a partial view for the menu and include it wherever needed.

To create a partial view, you typically create a separate .cshtml file and then render it within your main view using the Partial method:

<div class="sidebar">
    @await Html.PartialAsync("_Menu")
</div>

In this example, _Menu.cshtml is a partial view that contains the navigation menu.

4.2.2 Layout Sections

Layout sections allow you to define placeholders within your layout view that can be filled with content from individual views. This approach provides flexibility in customizing parts of your layout from different views.

Here’s an example of defining a layout section in your layout view (_Layout.cshtml):

<!DOCTYPE html> <html> <head> <title>@ViewBag.Title - My App</title>  </head> <body> <header> @await RenderSectionAsync("Header", required: false) </header>

<div class=“container”>
@RenderBody()
</div>

In this layout, RenderSectionAsync("Header", required: false) is a section placeholder for the header content. Individual views can specify content for this section like so:

@section Header {
    <h1>Welcome to My App</h1>
}

By using layout sections, you can maintain a consistent overall layout while allowing specific views to customize parts of it.

4.2.3 View Components

View components are a powerful way to encapsulate and reuse UI logic in your views. They are similar to partial views but come with the added capability of having their own associated logic. View components are especially useful for creating reusable, self-contained widgets or components within your web application.

Here’s a simple example of creating a view component:

public class ShoppingCartViewComponent : ViewComponent { public async Task<IViewComponentResult> InvokeAsync() { // Fetch shopping cart data here. var items = await ShoppingCartService.GetCartItemsAsync();

return View(items);

} }

In this example, the ShoppingCartViewComponent fetches shopping cart data and returns a view with that data.

To use the view component in a view, you can invoke it like this:

@await Component.InvokeAsync("ShoppingCart")

This will render the view component, and you can place it wherever needed within your view.

4.3 Advanced Routing and URL Generation

Efficient routing and URL generation are crucial for creating user-friendly and SEO-friendly web applications. In this section, we’ll explore advanced routing techniques and URL generation strategies.

4.3.1 Attribute Routing with Constraints

Attribute routing allows you to define custom constraints for route parameters. Constraints restrict the values that are allowed for a parameter, enhancing the robustness of your routing system.

For example, you can use constraints to specify that a route parameter must be a numeric value:

[HttpGet("products/{id:int}")]
public IActionResult ProductDetail(int id)
{
    // Fetch and display product details.
}

In this route configuration, {id:int} specifies that the id parameter must be an integer. If a non-integer value is provided in the URL, the route will not match, preventing potential errors.

4.3.2 Route Constraints

Route constraints are pre-defined checks that can be applied to route parameters to ensure they match specific criteria. ASP.NET Core provides various built-in route constraints, such as int, bool, alpha, datetime, and more.

Here’s an example of using a route constraint for a date parameter:

[HttpGet("events/{date:datetime}")]
public IActionResult EventsByDate(DateTime date)
{
    // Fetch and display events for the specified date.
}

In this route, the date:datetime constraint ensures that the date parameter is parsed as a valid DateTime value.

4.3.3 URL Generation

URL generation is the process of creating URLs for specific routes within your application. ASP.NET Core provides a robust URL generation system that allows you to generate URLs based on route names, route parameters, and route values.

For example, you can generate a URL for a specific route using the Url.Action method:

var url = Url.Action("ProductDetail", "Products", new { id = 123 });

In this example, ProductDetail is the name of the action, Products is the name of the controller, and id is a route parameter. The Url.Action method generates a URL that maps to the specified action and controller.

4.4 Advanced View Models

View models play a critical role in passing data from controllers to views. In this section, we’ll explore advanced techniques for working with view models to handle complex data scenarios.

4.4.1 View Model Composition

In real-world applications, view models often need to aggregate data from multiple sources. This can involve data from the database, external services, or calculations performed within the controller. View model composition allows you to create view models that are tailored to the specific needs of a view.

Consider a scenario where you need to display product details along with related products and user reviews. You can create a composite view model like this:

public class ProductDetailsViewModel
{
    public Product Product { get; set; }
    public List<Product> RelatedProducts { get; set; }
    public List<Review> Reviews { get; set; }
}

In the controller action, you populate this composite view model by fetching data from various sources. This ensures that the view receives all the necessary data in a structured format.

4.4.2 View Model Validation

View model validation is essential for ensuring that data submitted by users is accurate and conforms to your application’s requirements. ASP.NET Core provides built-in validation mechanisms that work seamlessly with view models.

To perform validation, you can use data annotations on view model properties to specify rules:

public class ProductViewModel { [Required] public string Name { get; set; }

[Range(0.01, double.MaxValue)]
public decimal Price { get; set; }

// Other properties and annotations }

In this example, the [Required] attribute ensures that the Name property is not empty, and the [Range] attribute sets constraints on the Price property.

In your controller action, you can check if the view model is valid using ModelState.IsValid and take appropriate actions based on validation results:

if (ModelState.IsValid)
{
    // Save the data and proceed.
}
else
{
    // Handle validation errors and return to the view with error messages.
}

4.4.3 View Components in View Models

View components can be a valuable part of your view models when you need to include dynamic or reusable components in your views. You can encapsulate the logic for rendering view components within your view models, allowing for a more organized and modular approach.

For example, you might include a shopping cart summary as a view component within a view model:

public class CheckoutViewModel
{
    public List<CartItem> CartItems { get; set; }
    public decimal TotalPrice { get; set; }
    public IViewComponentResult CartSummary { get; set; }
}

In your controller, you can create and populate the CartSummary view component:

var cartSummary = ViewComponent("CartSummary", new { cartItems, totalPrice });

This approach allows you to include view components as part of your view model and render them in your views seamlessly.

4.5 Conclusion of Chapter 4

In this chapter, we delved into advanced topics related to controllers and views in ASP.NET Core. We explored advanced controller concepts, including attribute routing, action filters, dependency injection, and model binding. Additionally, we discussed advanced view techniques, such as partial views, layout sections, and view components. Advanced routing and URL generation techniques were also covered, along with advanced view model strategies.

By mastering these advanced concepts, you can build more sophisticated and responsive web applications in ASP.NET Core. In the next chapter, we will explore data access and database interactions, a critical aspect of building dynamic web applications.

Congratulations! You’ve completed Chapter 4, gaining a deep understanding of advanced controllers and views in ASP.NET Core. These advanced techniques will empower you to create feature-rich and interactive web applications. In the upcoming chapters, we’ll continue our journey by exploring data access, authentication, and other crucial aspects of web development with ASP.NET Core.