An Atypical ASP.NET Core 6 Design Patterns Guide: A SOLID adventure into architectural principles and design patterns using .NET 6 and C# 10

Cover
Copyright
Contributors
Table of Contents
Preface
Section 1: Principles and Methodologies
Chapter 1: Introduction
	What is a design pattern?
	Anti-patterns and code smells
		Anti-patterns
			Anti-pattern – God Class
		Code smells
			Code smell – Control Freak
			Code smell – Long Methods
	Understanding the web – request/response
	Getting started with .NET
		.NET SDK versus runtime
		.NET 5+ versus .NET Standard
		Visual Studio Code versus Visual Studio versus the command-line interface
			An overview of project templates
			Running and building your program
		Technical requirements
	Summary
	Questions
	Further reading
Chapter 2: Automated Testing
	An overview of automated testing
		Unit testing
		Integration testing
		End-to-end testing
		Other types of tests
		Picking the right test style
		Testing approaches
		Refactoring
		Technical debt
	Testing .NET applications
		Creating an xUnit test project
		Getting started with xUnit
			Facts
			Assertions
			Theories
			Closing words
		Arrange, Act, Assert
		Organizing your tests
			Unit tests
			Integration tests
		ASP.NET Core integration testing
			Classic web application
			Minimal hosting
	Important testing principles
	Summary
	Questions
	Further reading
Chapter 3: Architectural Principles
	The SOLID principles
		Single responsibility principle (SRP)
			Project – BookStore
			What is an interface?
		Open/Closed principle (OCP)
			Project – IAttacker
		Liskov substitution principle (LSP)
			Project – HallOfFame
			Conclusion
		Interface segregation principle (ISP)
			Project – Ninja versus Pirate
			Project – Bookstore update
			Conclusion
		Dependency inversion principle (DIP)
			Direct dependency
			Inverted dependency
			Inverting subsystems using DIP
			Project – Dependency inversion
			Conclusion
			What’s next?
	Other important principles
		Separation of concerns
		Don’t repeat yourself (DRY)
		Keep it simple, stupid (KISS)
	Summary
	Questions
	Further reading
Section 2: Designing for ASP.NET Core
Chapter 4: The MVC Pattern Using Razor
	The Model View Controller design pattern
		Goal
		Design
		Anatomy of ASP.NET Core MVC
			Directory structure
			Controller
			Model
			View
			Default routing
		Conclusion
	The View Model design pattern
		Goal
		Design
		Project – View models (a list of students)
		Conclusion
	Summary
	Questions
	Further reading
Chapter 5: The MVC Pattern for Web APIs
	An overview of REST
		HTTP methods
		Status code
		HTTP headers
		Versioning
			Default versioning strategy
			Versioning strategy
		Wrapping up
	The Model View Controller design pattern
		Goal
		Design
		Anatomy of ASP.NET Core web APIs
			The entry point
			Directory structure
			Controller
			Returning values
			Attribute routing
		Conclusion
	The Data Transfer Object design pattern
		Goal
		Design
		Project – DTO
		Conclusion
	API contracts
	Summary
	Questions
	Further reading
Chapter 6: Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
	The Strategy design pattern
		Goal
		Design
		Project – Strategy
		Conclusion
	The Abstract Factory design pattern
		Goal
		Design
		Project – AbstractVehicleFactory
		Conclusion
	The Singleton design pattern
		Goal
		Design
		An alternate (better) way
		Code smell – Ambient Context
		Conclusion
	Summary
	Questions
Chapter 7: Deep Dive into Dependency Injection
	What is dependency injection?
		The composition root
		Registering your features elegantly
		Object lifetime
		Code smell – Control Freak
	Using external IoC containers
	Revisiting the Strategy pattern
		Constructor injection
		Property injection
		Method injection
		Project – Strategy
			Adding the View Model
			Adding a guard clause
		Conclusion
	Revisiting the Singleton pattern
		Project – Application state
		Project – Wishlist
		Conclusion
	Understanding the Service Locator pattern
		Project – ServiceLocator
			Implementing method injection
			Implementing constructor injection
			Implementing a minimal API
		Conclusion
	Revisiting the Factory pattern
		Project – Factory
		Conclusion
	Summary
	Questions
	Further reading
Chapter 8: Options and Logging Patterns
	The Options pattern
		Getting started
			IOptionsMonitor
			IOptionsFactory
			IOptionsSnapshot
			IOptions
		Project – CommonScenarios
			Named options
			Using settings
		Project – OptionsConfiguration
			Implementing a configurator object
			Using multiple configurator objects
			Exploring other configuration possibilities
		Project – OptionsValidation
			Eager validation
			Data annotations
			Validation types
		Project – OptionsValidationFluentValidation
		Workaround – Injecting options directly
		Conclusion
	Becoming familiar with .NET logging abstractions
		About logging
		Writing logs
		Log levels
		Logging providers
		Configuring logging
		Structured logging
		Conclusion
	Summary
	Questions
	Further reading
Section 3: Designing at Component Scale
Chapter 9: Structural Patterns
	Implementing the Decorator design pattern
		Goal
		Design
		Project – Adding behaviors
			DecoratorA
			DecoratorB
		Project – Decorator using Scrutor
		Conclusion
	Implementing the Composite design pattern
		Goal
		Design
		Project – BookStore
		Conclusion
	Implementing the Adapter design pattern
		Goal
		Design
		Project – Greeter
		Conclusion
	Implementing the Façade design pattern
		Goal
		Design
		Project – The façades
			Opaque façade
			Transparent façade
			The program
			Flexibility in action
			Alternative façade patterns
		Conclusion
	Summary
	Questions
	Further reading
Chapter 10: Behavioral Patterns
	Implementing the Template Method pattern
		Goal
		Design
		Project – Building a search machine
		Conclusion
	Implementing the Chain of Responsibility pattern
		Goal
		Design
		Project – Message interpreter
		Project – Improved message interpreter
		Project – A final, finer-grained design
		Conclusion
	Summary
	Questions
Chapter 11: Understanding the Operation Result Design Pattern
	The Operation Result pattern
		Goal
		Design
		Project – Implementing different Operation Result patterns
			The consumer
			The simplest form of the Operation Result pattern
			A single error message
			Adding a return value
			Multiple error messages
			Adding message severity
			Sub-classes and factories
		Advantages and disadvantages
			Advantages
			Disadvantages
	Summary
	Questions
	Further reading
Section 4: Designing at Application Scale
Chapter 12: Understanding Layering
	Introducing layering
		Classic layering model
		Splitting the layers
		Layers versus tiers versus assemblies
			What is an assembly?
	Responsibilities of the common layers
		Presentation
		Domain
			Rich domain model
			Anemic domain model
			Service layer
		Data
			Repository pattern
			Unit of Work pattern
	Abstract layers
	Sharing the model
	Clean Architecture
	Implementing layering in real life
		To be or not to be a purist?
		Building a façade over a database
	Summary
	Questions
	Further reading
Chapter 13: Getting Started with Object Mappers
	Object mapper
		Goal
		Design
		Project – Mapper
		Code smell – Too many dependencies
		Pattern – Aggregate Services
		Pattern – Mapping Façade
		Project – Mapping service
		Project – AutoMapper
		Conclusion
	Summary
	Questions
	Further reading
Chapter 14: Mediator and CQRS Design Patterns
	A high-level overview of Vertical Slice Architecture
	Implementing the Mediator pattern
		Goal
		Design
		Project – Mediator (IMediator)
		Project – Mediator (IChatRoom)
		Conclusion
	Implementing the CQRS pattern
		Goal
		Design
		Project – CQRS
		Code smell – Marker Interfaces
			Metadata
			Dependency identifier
		Conclusion
	Using MediatR as a mediator
		Project – Clean Architecture with MediatR
		Conclusion
	Summary
	Questions
	Further reading
Chapter 15: Getting Started with Vertical Slice Architecture
	Vertical Slice Architecture
		What are the advantages and disadvantages?
		Anti-pattern – Big Ball of Mud
		Project – Vertical Slice Architecture
			Project organization
			Exploring a feature
			Request validation
			Testing
		Continuing your journey
		Conclusion
	Summary
	Questions
	Further reading
Chapter 16: Introduction to Microservices Architecture
	What are microservices?
		Cohesive unit of business
		Ownership of data
		Microservice independence
	An introduction to event-driven architecture
		Domain events
		Integration events
		Application events
		Enterprise events
		Conclusion
	Getting started with message queues
		Conclusion
	Implementing the Publish-Subscribe pattern
		Message brokers
		The event sourcing pattern
		Example
		Conclusion
	Introducing Gateway patterns
		Gateway Routing pattern
		Gateway Aggregation pattern
		Backends for Frontends pattern
		Mixing and matching gateways
		Conclusion
	Revisiting the CQRS pattern
		Conclusion
	Exploring the Microservice Adapter pattern
		Adapting an existing system to another
		Decommissioning a legacy application
		Adapting an event broker to another
		Conclusion
	Summary
	Questions
	Further reading
Section 5: Designing the Client Side
Chapter 17: ASP.NET Core User Interfaces
	Getting familiar with Razor Pages
		Design
		Routing
		Conclusion
	Organizing the user interface
		Partial views
			Project – Shared form
			Conclusion
		Tag Helpers
			Built-in Tag Helpers
			Creating a custom Tag Helper
			Creating an RSS feed TagHelperComponent
			Conclusion
		View components
			Project – Reusable employee count
			Conclusion
	Display and editor templates
		Display templates
		Editor templates
		Project – Composite BookStore revisited
		Conclusion
	Summary
	Questions
	Further reading
Chapter 18: A Brief Look into Blazor
	Overview of Blazor Server
	Overview of Blazor WebAssembly
	Getting familiar with Razor components
		Creating Razor components
			C#-only components
			Razor-only components
			Razor and C# hybrid components
		CSS isolation
		Component life cycle
		Event handling
	The Model-View-Update pattern
		Goal
		Design
		Project – Counter
		Conclusion
	A medley of Blazor features
	Summary
	Questions
	Further reading
	An end is simply a new beginning
Appendices
Appendix A
	Older C# features
		The null-coalescing operator (C# 2.0)
		Expression-bodied member (C# 6-7)
		Throw expressions (C# 7.0)
		Tuples (C# 7.0+)
		Default literal expressions (C# 7.1)
		Switch expressions (C# 8)
		Discards (C# 7)
		Async main (C# 7.1)
		User-defined conversion operators (C# 1)
		Local functions (C# 7) and a static local function (C# 8)
	What’s new in .NET 5 and C# 9?
		Top-level statements
		Target-typed new expressions
		Init-only properties
		Record classes
			Simplifying the record creation
			The with keyword
			Deconstruction
			Equality comparison
			Conclusion
	What’s new in .NET 6 and C# 10?
		File-scoped namespaces
		Global using directives
		Implicit using directives
		Constant interpolated strings
		Record struct
		Minimal hosting model
		Minimal APIs
		Nullable reference types
Appendix B
	An overview of containers
	Docker
		Docker Compose
	Orchestration
		Project Tye
		Kubernetes
	Scaling
	Summary
	Further reading
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
Acronyms Lexicon
	Other Books You May Enjoy
PacktPage
Other Books You May Enjoy
Index