This section explored the MVC pattern, how to create controllers and action methods, and how to route requests to those actions.We could talk about MVC for the remainder of the book, but we would be missing the point. The subset of features we covered here should be enough theory to fill the gap you might have had and allow you to understand the code samples that leverage ASP.NET Core MVC.Using the MVC pattern helps us follow the SOLID principles in the following ways:
- S: The MVC pattern divides the rendering of a data structure into three different roles. The framework handles most of the serialization portion (the View), leaving us only two pieces to manage: the Model and the Controller.
- O: N/A
- L: N/A
- I: Each controller handles a subset of features and represents a smaller interface into the system. MVC makes the system easier to manage than having a single entry point for all routes, like a single controller.
- D: N/A
Next, we explore the Data Transfer Object pattern to isolate the API’s model from the domain.
Using MVC with DTOs
This section explores leveraging the Data Transfer Object (DTO) pattern with the MVC framework.
This section is the same as we explore in Chapter 5, Minimal APIs, but in the context of MVC. Moreover, the two code projects are part of the same Visual Studio solution for convenience, allowing you to compare the two implementations.
Goal
As a reminder, DTOs aim to control the inputs and outputs of an endpoint by decoupling the API contract from the application’s inner workings. DTOs empower us to define our APIs without thinking about the underlying data structures, leaving us to craft our REST APIs how we want.
We discuss REST APIs and DTOs more in-depth in Chapter 4, REST APIs.
Other possible objectives are to save bandwidth by limiting the amount of information the API transmits, flattening the data structure, or adding API features that cross multiple entities.
Design
Let’s start by analyzing a diagram that expands MVC to work with DTOs:
Figure 6.2: MVC workflow with a DTO
DTOs allow the decoupling of the domain from the view (data) and empower us to manage the inputs and outputs of our REST APIs independently from the domain. The controller still manipulates the domain model but returns a serialized DTO instead.
Project – MVC API
This code sample is the same as in the previous chapter but uses the MVC framework instead of Minimal APIs.Context: we must build an application to manage customers and contracts. We must track the state of each contract and have a primary contact in case the business needs to contact the customer. Finally, we must display the number of contracts and the number of opened contracts for each customer on a dashboard.As a reminder, the model is the following:
namespace Shared.Models;
public record class Customer(
int Id,
string Name,
List<Contract> Contracts
);
public record class Contract(
int Id,
string Name,
string Description,
WorkStatus Status,
ContactInformation PrimaryContact
);
public record class WorkStatus(int TotalWork, int WorkDone)
{
public WorkState State =>
WorkDone == 0 ?
WorkState.New :
WorkDone == TotalWork ?
WorkState.Completed :
WorkState.InProgress;
}
public record class ContactInformation(
string FirstName,
string LastName,
string Email
);
public enum WorkState
{
New,
InProgress,
Completed
}
The preceding code is straightforward. The only piece of logic is the WorkStatus.State property that returns WorkState.New when the work has not yet started on that contract, WorkState.Completed when all the work is completed, or WorkState.InProgress otherwise.The controllers leverage the ICustomerRepository interface to simulate database operations. The implementation is unimportant. It uses a List<Customer> as the database. Here’s the interface that allows querying and updating the data:
using Shared.Models;
namespace Shared.Data;
public interface ICustomerRepository
{
Task<IEnumerable<Customer>> AllAsync(
CancellationToken cancellationToken);
Task<Customer> CreateAsync(
Customer customer,
CancellationToken cancellationToken);
Task<Customer?> DeleteAsync(
int customerId,
CancellationToken cancellationToken);
Task<Customer?> FindAsync(
int customerId,
CancellationToken cancellationToken);
Task<Customer?> UpdateAsync(
Customer customer,
CancellationToken cancellationToken);
}
Now that we know about the underlying foundation, we explore a CRUD controller that does not leverage DTOs.