Book Image

An Atypical ASP.NET Core 5 Design Patterns Guide

By : Carl-Hugo Marcotte
Book Image

An Atypical ASP.NET Core 5 Design Patterns Guide

By: Carl-Hugo Marcotte

Overview of this book

Design patterns are a set of solutions to many of the common problems occurring in software development. Knowledge of these design patterns helps developers and professionals to craft software solutions of any scale. ASP.NET Core 5 Design Patterns starts by exploring basic design patterns, architectural principles, dependency injection, and other ASP.NET Core mechanisms. You’ll explore the component scale as you discover patterns oriented toward small chunks of the software, and then move to application-scale patterns and techniques to understand higher-level patterns and how to structure the application as a whole. The book covers a range of significant GoF (Gangs of Four) design patterns such as strategy, singleton, decorator, facade, and composite. The chapters are organized based on scale and topics, allowing you to start small and build on a strong base, the same way that you would develop a program. With the help of use cases, the book will show you how to combine design patterns to display alternate usage and help you feel comfortable working with a variety of design patterns. Finally, you’ll advance to the client side to connect the dots and make ASP.NET Core a viable full-stack alternative. By the end of the book, you’ll be able to mix and match design patterns and have learned how to think about architecture and how it works.

Related Content you might be interested in

Current Title:

Small book image
An Atypical ASP.NET Core 5 Design Patterns Guide
Carl-Hugo Marcotte
Dec, 2020 | 762 pages
Small book image
Customizing ASP.NET Core 5.0
Jrgen Gutsch
Jan, 2021 | 160 pages
Small book image
Enterprise Application Development with C# 9 and .NET 5
Arun Kumar Tamirisa | Ravindra Akella | Suneel Kumar Kunani | Bhupesh Guptha Muthiyalu
Mar, 2021 | 610 pages
Small book image
Hands-On RESTful Web Services with ASP.NET Core 3
Samuele Resca
Dec, 2019 | 510 pages
Table of Contents (27 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
1
Section 1: Principles and Methodologies
Section 1: Principles and Methodologies
Free Chapter
2
Chapter 1: Introduction to .NET
Chapter 1: Introduction to .NET
What is a design pattern?
Anti-patterns and code smells
Understanding the web – Request/Response
Getting started with .NET
Summary
Questions
Further reading
3
Chapter 2: Testing Your ASP.NET Core Application
Chapter 2: Testing Your ASP.NET Core Application
Overview of automated testing and how it applies to ASP.NET Core
Test-driven development (TDD)
Testing made easy through ASP.NET Core
Summary
Questions
Further reading
4
Chapter 3: Architectural Principles
Chapter 3: Architectural Principles
The SOLID principles
Other important principles
Summary
Questions
5
Section 2: Designing for ASP.NET Core
Section 2: Designing for ASP.NET Core
6
Chapter 4: The MVC Pattern using Razor
Chapter 4: The MVC Pattern using Razor
The Model View Controller design pattern
MVC using Razor
View Model design pattern
Summary
Questions
Further reading
7
Chapter 5: The MVC Pattern for Web APIs
Chapter 5: The MVC Pattern for Web APIs
An overview of REST
Anatomy of a web API
C# features
The Data Transfer Object design pattern
API contracts
Summary
Questions
Further reading
8
Chapter 6: Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
Chapter 6: Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
The Strategy design pattern
A brief look at a few C# features
The Abstract Factory design pattern
The Singleton design pattern
Summary
Questions
9
Chapter 7: Deep Dive into Dependency Injection
Chapter 7: Deep Dive into Dependency Injection
What is Dependency Injection?
Using external IoC containers
Revisiting the Strategy pattern
Revisiting the Singleton pattern
Understanding the Service Locator pattern
Revisiting the Factory pattern
Summary
Questions
Further reading
10
Chapter 8: Options and Logging Patterns
Chapter 8: Options and Logging Patterns
An overview of the Options pattern
Getting familiar with .NET logging abstractions
Summary
Questions
Further reading
11
Section 3: Designing at Component Scale
Section 3: Designing at Component Scale
12
Chapter 9: Structural Patterns
Chapter 9: Structural Patterns
Implementing the Decorator design pattern
Implementing the Composite design pattern
Implementing the Adapter design pattern
Implementing the Façade design pattern
Summary
Questions
Further reading
13
Chapter 10: Behavioral Patterns
Chapter 10: Behavioral Patterns
Implementing the Template Method pattern
Implementing the Chain of Responsibility pattern
Summary
Questions
14
Chapter 11: Understanding the Operation Result Design Pattern
Chapter 11: Understanding the Operation Result Design Pattern
Goal
Design
Project – Implementing different Operation Result patterns
Advantages and disadvantages
Summary
Questions
Further reading
15
Section 4: Designing at Application Scale
Section 4: Designing at Application Scale
16
Chapter 12: Understanding Layering
Chapter 12: Understanding Layering
Introduction to layering
Responsibilities of the common layers
Abstract data layer
Shared rich model
Clean Architecture
Summary
Questions
Further reading
17
Chapter 13: Getting Started with Object Mappers
Chapter 13: Getting Started with Object Mappers
Overview of object mapping
Project: Mapper
Project – Mapping service
Project – AutoMapper
Summary
Questions
Further reading
18
Chapter 14: Mediator and CQRS Design Patterns
Chapter 14: Mediator and CQRS Design Patterns
A high-level overview of Vertical Slice Architecture
Implementing the Mediator pattern
Implementing the CQRS pattern
Using MediatR as a mediator
Summary
Questions
Further reading
19
Chapter 15: Getting Started with Vertical Slice Architecture
Chapter 15: Getting Started with Vertical Slice Architecture
Vertical Slice Architecture
Project: Vertical Slice Architecture
Continuing your journey
Summary
Questions
Further reading
20
Chapter 16: Introduction to Microservices Architecture
Chapter 16: Introduction to Microservices Architecture
What are microservices?
Getting started with message queues
An overview of events
Implementing the Publish-Subscribe pattern
Introducing Gateway patterns
Revisiting the CQRS pattern
An overview of containers
Summary
Questions
Further reading
21
Section 5: Designing the Client Side
Section 5: Designing the Client Side
22
Chapter 17: ASP.NET Core User Interfaces
Chapter 17: ASP.NET Core User Interfaces
Getting familiar with Razor Pages
Organizing the user interface
C# 9 features
Display and Editor Templates
Summary
Questions
Further reading
23
Chapter 18: A Brief Look into Blazor
Chapter 18: A Brief Look into Blazor
An overview of Blazor Server
Overview of Blazor WebAssembly
Getting familiar with Razor components
The Model-View-Update pattern
A medley of Blazor features
Summary
Questions
Further reading
An end is simply a new beginning
24
Assessment Answers
Assessment Answers
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13
Chapter 14
Chapter 15
Chapter 16
Chapter 17
Chapter 18
25
Acronyms Lexicon
Acronyms Lexicon
26
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Continuing your journey

The previous project was tiny. It had a shared model that served as the data layer because that model was composed of only a single class. When you are building a bigger application, you will most likely have more than a class, so I'll try to give you a good starting point to tackle bigger apps. The idea is to create slices that are as small as possible, limit interactions with other slices as much as possible, then refactor that code into better code. We cannot remove coupling, so we need to organize it instead.

Here is a workflow that we could call "start small and refactor":

  1. Write the contracts that cover your feature (input and output).
  2. Write one or more integration tests that cover your feature, using those contracts; the Query or Command class (IRequest) as input and the Result class as output.
  3. Implement your Handler, Validator, MapperProfile, and any other bit that needs to be coded. At this point, the code could be a...
Previous Section
End of Section 4
Next Section