Book Image

An Atypical ASP.NET Core 6 Design Patterns Guide - Second Edition

By : Carl-Hugo Marcotte
5 (1)
Book Image

An Atypical ASP.NET Core 6 Design Patterns Guide - Second Edition

5 (1)
By: Carl-Hugo Marcotte

Overview of this book

An Atypical ASP.NET Core 6 Design Patterns Guide, Second Edition approaches programming like playing with LEGO®: snapping small pieces together to create something beautiful. Thoroughly updated for ASP.NET Core 6, with further coverage of microservices patterns, data contracts, and event-driven architecture, this book gives you the tools to build and glue reliable components together to improve your programmatic masterpieces. The chapters are organized based on scale and topic, allowing you to start small and build on a strong base, the same way that you would develop a program. You will begin by exploring basic design patterns, SOLID architectural principles, dependency injection, and other ASP.NET Core 6 mechanisms. You will explore component-scale patterns, and then move to higher level application-scale patterns and techniques to better structure your applications. Finally, you'll advance to the client side to connect the dots with tools like Blazor and make ASP.NET Core a viable full-stack web development framework. You will supplement your learning with practical use cases and best practices, exploring a range of significant Gang of Four (GoF) design patterns along the way. By the end of the book, you will be comfortable combining and implementing patterns in different ways, and crafting software solutions of any scale.

Related Content you might be interested in

Current Title:

Small book image
An Atypical ASP.NET Core 6 Design Patterns Guide - Second Edition
Carl-Hugo Marcotte
Mar, 2022 | 678 pages
Small book image
Enterprise Application Development with C# 10 and .NET 6
Arun Kumar Tamirisa | Ravindra Akella | Suneel Kumar Kunani | Bhupesh Guptha Muthiyalu
Jun, 2022 | 586 pages
Small book image
ASP.NET Core 5 for Beginners
Andreas Helland | Vincent Maverick Durano | Jeffrey Chilberto | Ed Price
Dec, 2020 | 602 pages
Small book image
Customizing ASP.NET Core 6.0
Jrgen Gutsch
Dec, 2021 | 204 pages
Table of Contents (31 chapters)
Preface
Preface
Free Chapter
1
Section 1: Principles and Methodologies
Section 1: Principles and Methodologies
2
Introduction
Introduction
What is a design pattern?
Anti-patterns and code smells
Understanding the web – request/response
Getting started with .NET
Summary
Questions
Further reading
3
Automated Testing
Automated Testing
An overview of automated testing
Testing .NET applications
Important testing principles
Summary
Questions
Further reading
4
Architectural Principles
Architectural Principles
The SOLID principles
Other important principles
Summary
Questions
Further reading
5
Section 2: Designing for ASP.NET Core
Section 2: Designing for ASP.NET Core
6
The MVC Pattern Using Razor
The MVC Pattern Using Razor
The Model View Controller design pattern
The View Model design pattern
Summary
Questions
Further reading
7
The MVC Pattern for Web APIs
The MVC Pattern for Web APIs
An overview of REST
The Model View Controller design pattern
The Data Transfer Object design pattern
API contracts
Summary
Questions
Further reading
8
Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
The Strategy design pattern
The Abstract Factory design pattern
The Singleton design pattern
Summary
Questions
9
Deep Dive into Dependency Injection
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
Options and Logging Patterns
Options and Logging Patterns
The Options pattern
Becoming familiar with .NET logging abstractions
Summary
Questions
Further reading
11
Section 3: Designing at Component Scale
Section 3: Designing at Component Scale
12
Structural Patterns
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
Behavioral Patterns
Behavioral Patterns
Implementing the Template Method pattern
Implementing the Chain of Responsibility pattern
Summary
Questions
14
Understanding the Operation Result Design Pattern
Understanding the Operation Result Design Pattern
The Operation Result pattern
Summary
Questions
Further reading
15
Section 4: Designing at Application Scale
Section 4: Designing at Application Scale
16
Understanding Layering
Understanding Layering
Introducing layering
Responsibilities of the common layers
Abstract layers
Sharing the model
Clean Architecture
Implementing layering in real life
Summary
Questions
Further reading
17
Getting Started with Object Mappers
Getting Started with Object Mappers
Object mapper
Summary
Questions
Further reading
18
Mediator and CQRS Design Patterns
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
Getting Started with Vertical Slice Architecture
Getting Started with Vertical Slice Architecture
Vertical Slice Architecture
Summary
Questions
Further reading
20
Introduction to Microservices Architecture
Introduction to Microservices Architecture
What are microservices?
An introduction to event-driven architecture
Getting started with message queues
Implementing the Publish-Subscribe pattern
Introducing Gateway patterns
Revisiting the CQRS pattern
Exploring the Microservice Adapter pattern
Summary
Questions
Further reading
21
Section 5: Designing the Client Side
Section 5: Designing the Client Side
22
ASP.NET Core User Interfaces
ASP.NET Core User Interfaces
Getting familiar with Razor Pages
Organizing the user interface
Display and editor templates
Summary
Questions
Further reading
23
A Brief Look into Blazor
A Brief Look into Blazor
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
27
Index
Index
Appendices
Appendices
Appendix A
Appendix A
Older C# features
What’s new in .NET 5 and C# 9?
What’s new in .NET 6 and C# 10?
Appendix B
Appendix B
An overview of containers
Docker
Orchestration
Scaling
Summary
Further reading

Implementing the Decorator design pattern

The Decorator pattern allows us to extend objects at runtime while separating responsibilities. It is a simple but powerful pattern. In this section, we explore how to implement this pattern in the traditional way and how to leverage an open source tool named Scrutor to help us create powerful dependency injection-ready decorators using .NET.

Goal

The decorator’s goal is to extend an existing object, at runtime, without changing its code. Moreover, the decorated object should not be aware that it is being decorated, leaving it as a great candidate for long-lived or complex systems that need to evolve. This pattern fits systems of all sizes.

I often use this pattern to add flexibility and create adaptability to a program for next to no cost. In addition, small classes are easier to test, so the Decorator pattern adds ease of testability into the mix, making it worth mastering.

The Decorator pattern makes it easier to...

Previous Section
End of Section 2
Next Section