Architecting ASP.NET Core Applications: Best Practices

By Gill Cleeren
Creating a testable and maintainable application in .NET Core requires a solid foundation. This course will teach you best practices for creating an architecture for your ASP.NET Core applications.
Play course overview
Course info
Rating
(35)
Level
Intermediate
Updated
Jan 8, 2021
Duration
3h 59m
Table of contents
Course Overview
Course Overview 2m
Course Introduction
Module Introduction 2m A Solid Architecture for .NET Core Applications at GloboTicket 5m What You Need to Know before Starting 2m Demo: Looking at the Finished Application 2m
Understanding Foundational Architectural Principles
Module Introduction 1m Foundational Architectural Principles 8m Different Application Architecture Styles 6m Understanding Clean Architecture 11m Summary 1m
Setting up the Application Core
Module Introduction 2m Understanding the Business Requirements 4m Setting up the Application Architecture 1m Demo: Creating the Visual Studio Solution 1m Creating the Domain Project 0m Demo: Creating the Domain Project 2m Designing the Application Project 4m Demo: Creating the Application Project 3m Using MediatR and AutoMapper 7m Demo: Writing the Application Logic in the Request Handler 12m Introducing CQRS into the Architecture 4m Demo: Adding CQRS into the Application Architecture 2m Understanding Features 1m Demo: Organizing the Code Using Features 5m Demo: Using Commands to Create a New Entity 5m Adding Validation Using Fluent Validation 4m Demo: Adding Validation and Custom Exceptions 9m Summary 1m
Creating the Infrastructure Project
Module Introduction 1m Understanding the Goal of the Infrastructure Projects 2m Adding Data Persistence with Entity Framework Core 2m Demo: Adding Entity Framework Core 5m Demo: Implementing the Persistence Layer 5m Adding the Infrastructure Project 1m Demo: Adding Support for Mailing from the Infrastructure 7m Summary 1m
Adding an API Using ASP.NET Core
Module Introduction 2m Creating the API Project 3m Demo: Adding the API Project 6m Transitioning from View Services to MediatR 5m Demo: Adding Controller Code Using MediatR 5m Deciding Which Objects to Return 3m Demo: Returning View Models and Responses 4m Demo: Adding Support for Returning a CSV File 4m Exposing the API Functionality Using Swagger 3m Demo: Adding Support for Swagger 2m Summary 1m
Testing the Application Code
Module Introduction 1m Understanding the Different Test Types 6m Creating Unit Tests 1m Demo: Creating Unit Tests for the Application Code 4m Demo: Writing Integration Tests for Infrastructure 2m Demo: Writing Integration Tests for the API Controllers 3m Summary 1m
Adding a UI
Module Introduction 1m Introducing Blazor Client-side 4m Using NSwag and NSwagStudio 3m Demo: Generating Client Code Using Nswag 6m Exploring the Client App 1m Demo: Exploring the Blazor Application 3m Demo: Adding the Paging Functionality End-to-end 5m Summary 1m
Improving on the Application’s Behavior
Module Introduction 1m Handling Errors in the API 5m Demo: Handing Errors 3m Adding Logging to the Architecture 4m Demo: Adding Logging to the Application 2m Authenticating Users 4m Demo: Adding Authentication Using Tokens 5m Demo: Adding Authentication to the Blazor App 2m Summary and Course Closing 1m
Description
Course info
Rating
(35)
Level
Intermediate
Updated
Jan 8, 2021
Duration
3h 59m
Description

Setting up an application architecture isn’t a straightforward task. Decisions made early in the process can have a large impact later on, and maintainability and testability play an important role. In this course, Architecting ASP.NET Core Applications: Best Practices, you’ll learn how to create a testable and maintainable architecture for ASP.NET Core. First, you’ll explore foundational architectural principles which help with the creation of maintainable code. Next, you’ll discover how to set up a real-world application architecture with ASP.NET Core. Finally, you’ll learn how to plug in different, common blocks such as logging and authentication. When you’re finished with this course, you’ll have the skills and knowledge of creating a testable and maintainable ASP.NET Core application needed to architect real-world, enterprise .NET Core apps.

About the author
Gill Cleeren
About the author

Gill Cleeren is a solution architect, author, and trainer in mobile and web technologies. He's also a Microsoft Regional Director and MVP. He lives in Tienen, Belgium.

More from the author
Building Web Applications with ASP.NET Core MVC
Beginner
4h 24m
Dec 14, 2020
Blazor: Getting Started
Beginner
4h 1m
Nov 30, 2020
More courses by Gill Cleeren
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Gill Cleeren, and welcome to my course, Architecting ASP.NET Core Applications: Best Practices. I'm the CTO of Xpirit Belgium and help customers with web and mobile application development. Creating an enterprise ASP.NET Core application can be a challenging task no matter if you choose to create an API combined with Angular, an MVC application or a Razor Pages application. Understanding how to set up an architecture that has proven itself for building real‑world applications and knowing which packages to use is a valuable asset for your next assignment. This course is aimed at giving you the knowledge of how to build a large enterprise‑ready ASP.NET Core API. In this course, you will build this API using clean architecture and by applying best practices and good architectural principles. You'll understand how to create a testable and maintainable code base that lends itself well to testing its different building blocks. You'll see how an API can be consumed from a client‑side application so to understand the full end‑to‑end application. Some of the major topics that we will cover include understand clean architecture and apply it to ASP.NET Core API, learn best practices and foundational architectural principles, including dependency inversion and separation of concerns, create a testable and maintainable code base and learn how to write unit tests for it, see how the API can be exposed using Swagger and consumed from a client‑side application that we will build with Blazor, implement crosscutting concerns in the API, including logging, exception handling, and authentication in a clean way. By the end of the course, you'll understand how a real‑life enterprise application built with ASP.NET Core API can be created. Before beginning the course, you should be familiar with ASP.NET Core, and you should also be familiar with the principles of REST. I hope you'll join me on this journey to learn how to build real‑life APIs powered by good architectural design in the Architecting ASP.NET Core Applications: Best Practices course, here at Pluralsight.

You're the smartest person in the room

PROVE IT

Your team won't just close the skills gap

THEY'LL HURDLE IT