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

Length: 678 pages
Edition: 2
Language: English
Publisher: Packt Publishing
Publication Date: 2022-03-28
ISBN-10: 1803249846
ISBN-13: 9781803249841
Sales Rank: #431410 (See Top 100 Books)

The professional developer’s essential guide to building robust, maintainable, and flexible web apps by leveraging C# 10 and .NET 6 features and component- and application-scale design patterns

Key Features

Apply the SOLID architectural principles and software design patterns effectively with a focus on dependency injection
Discover modern application architectures such as vertical slice, clean architecture, and event-driven microservices
Explore full-stack ASP.NET Core with an overview of Blazor

Book Description

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.

What you will learn

Apply the SOLID principles for building flexible and maintainable software
Get to grasp .NET dependency Injection
Work with GoF design patterns such as strategy, decorator, facade, and composite
Explore the MVC patterns for designing web APIs and web applications using Razor
Discover layering techniques and tenets of clean architecture
Become familiar with CQRS and vertical slice architecture as an alternate to layering
Understand microservices and when they can benefit your applications
Build an ASP.NET user interfaces from server-side to client-side Blazor

Who this book is for

The book is intended for intermediate software and web developers with an understanding of .NET who want to write flexible, maintainable, and robust code for building scalable web applications. Knowledge of C# programming and an understanding of web concepts like HTTP is necessary.

Preface
Section 1: Principles and Methodologies
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
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
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
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
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
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
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
Options and Logging Patterns
    The Options pattern
        Getting started
            IOptionsMonitor<TOptions>
            IOptionsFactory<TOptions>
            IOptionsSnapshot<TOptions>
            IOptions<TOptions>
        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
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
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
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
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
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
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
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
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
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
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
Index

.NET C & C++ Windows Programming C#Microsoft Programming Programming Languages

Donate to keep this site alive

To access the Link, solve the captcha.

How to download source code?

1. Go to: https://github.com/PacktPublishing

2. In the Find a repository… box, search the book title: An Atypical ASP.NET Core 6 Design Patterns Guide: A SOLID adventure into architectural principles and design patterns using .NET 6 and C# 10, 2nd Edition, sometime you may not get the results, please search the main title.