Clean Architecture in .NET

An overview of ASP.NET Core and ASP.NET Core APIs

In this first chapter, we will make sure we’re all on the same page about ASP.NET Core and creating APIs with the technology. Although having previous experience with ASP.NET Core will come in handy, you will learn all that’s required about some of the foundational concepts such as dependency injection, middleware and more.

Introducing core architectural principles and clean architecture

Clean architecture is in essence not much more than applying well-known architectural principles in a correct way. Most developers will know these but we will start with an overview of these. Next, we will inspect the concept of clean architecture and the different parts that make up the structure of it.

Creating the application core

We will start the creation of our application from the very core. In this chapter, we will understand how to structure code around contracts, apply clean structuring, add CQRS, implement business rules and much more. We will see how common packages such as Mediator and AutoMapper can be used correctly here.

Adding the infrastructure layer

So far, our code is nicely structured but it doesn’t “do” a lot yet. That’ll quickly change in this chapter when we start adding infrastructure concerns. This will bring in functionalities such as data access based on EF Core and working with external services.

Adding an API

We’ve written a lot of code already but now we’ll want to see the fruits of our hard labor. We’ll start with the creation of the API that’ll use the core and infrastructure code that we have created. On this API, we’ll also enable the use of Swagger so that it can more easily be consumed from clients.

Writing tests

We started of with the idea that the code we’re going to create is more testable, so now the proof is in the pudding. We’ll create tests for the different parts of the application that we have written so far.

Understanding ASP.NET Core Blazor

Blazor introduces a radical new way for .NET developers to build client-side applications and with .NET 10, also server-side rendered applications. We will in this chapter understand the core concepts of Blazor, which we’ll use to consume the API.

Adding the Blazor UI

Although it’s not the focus of this course to create a UI, it’s definitely useful to see how we can interact with our newly created API. In this chapter, we will learn how we can generate code for the client and we’ll build the Blazor app together that uses the API.

Completing the API with extra behaviors

Our API is functional but there are areas where improvements can be made. In this final chapter, we will extend our API with other cross-cutting concerns such as authentication, logging and more.