book

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

Name: An Atypical ASP.NET Core 6 Design Patterns Guide - Second Edition
Author: Marcotte
ISBN: 9781803249841

by Marcotte

March 2022

Intermediate to advanced

678 pages

17h 12m

English

Packt Publishing

Read now

Unlock full access

Preface
Section 1: Principles and Methodologies
Introduction
What is a design pattern?Anti-patterns and code smellsAnti-patternsAnti-pattern – God ClassCode smellsCode smell – Control FreakCode smell – Long MethodsUnderstanding the web – request/responseGetting started with .NET.NET SDK versus runtime.NET 5+ versus .NET StandardVisual Studio Code versus Visual Studio versus the command-line interface An overview of project templatesRunning and building your programTechnical requirementsSummaryQuestionsFurther reading
Automated Testing
An overview of automated testingUnit testingIntegration testingEnd-to-end testingOther types of testsPicking the right test styleTesting approachesRefactoringTechnical debtTesting .NET applicationsCreating an xUnit test projectGetting started with xUnitFactsAssertionsTheoriesClosing wordsArrange, Act, AssertOrganizing your testsUnit testsIntegration testsASP.NET Core integration testingClassic web applicationMinimal hostingImportant testing principlesSummaryQuestionsFurther reading
Architectural Principles
The SOLID principlesSingle responsibility principle (SRP)Project – BookStoreWhat is an interface?Open/Closed principle (OCP)Project – IAttackerLiskov substitution principle (LSP)Project – HallOfFameConclusionInterface segregation principle (ISP)Project – Ninja versus PirateProject – Bookstore updateConclusionDependency inversion principle (DIP)Direct dependencyInverted dependencyInverting subsystems using DIPProject – Dependency inversionConclusionWhat’s next?Other important principlesSeparation of concernsDon’t repeat yourself (DRY)Keep it simple, stupid (KISS)SummaryQuestionsFurther reading
Section 2: Designing for ASP.NET Core
The MVC Pattern Using Razor
The Model View Controller design patternGoalDesignAnatomy of ASP.NET Core MVCDirectory structureControllerModelViewDefault routingConclusionThe View Model design patternGoalDesignProject – View models (a list of students)ConclusionSummaryQuestionsFurther reading
The MVC Pattern for Web APIs
An overview of RESTHTTP methodsStatus codeHTTP headersVersioningDefault versioning strategyVersioning strategyWrapping upThe Model View Controller design patternGoalDesignAnatomy of ASP.NET Core web APIsThe entry pointDirectory structureControllerReturning valuesAttribute routingConclusionThe Data Transfer Object design patternGoalDesignProject – DTOConclusionAPI contractsSummaryQuestionsFurther reading
Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
The Strategy design patternGoalDesignProject – StrategyConclusionThe Abstract Factory design patternGoalDesignProject – AbstractVehicleFactoryConclusionThe Singleton design patternGoalDesignAn alternate (better) wayCode smell – Ambient ContextConclusionSummaryQuestions
Deep Dive into Dependency Injection
What is dependency injection?The composition rootRegistering your features elegantlyObject lifetimeCode smell – Control FreakUsing external IoC containersRevisiting the Strategy patternConstructor injectionProperty injectionMethod injectionProject – StrategyAdding the View ModelAdding a guard clauseConclusionRevisiting the Singleton patternProject – Application stateProject – WishlistConclusionUnderstanding the Service Locator patternProject – ServiceLocatorImplementing method injectionImplementing constructor injectionImplementing a minimal APIConclusionRevisiting the Factory patternProject – FactoryConclusionSummaryQuestionsFurther reading

Options and Logging Patterns
The Options patternGetting startedIOptionsMonitor<TOptions>IOptionsFactory<TOptions>IOptionsSnapshot<TOptions>IOptions<TOptions>Project – CommonScenariosNamed optionsUsing settingsProject – OptionsConfigurationImplementing a configurator objectUsing multiple configurator objectsExploring other configuration possibilitiesProject – OptionsValidationEager validationData annotationsValidation typesProject – OptionsValidationFluentValidationWorkaround – Injecting options directlyConclusionBecoming familiar with .NET logging abstractionsAbout loggingWriting logsLog levelsLogging providersConfiguring loggingStructured loggingConclusionSummaryQuestionsFurther reading
Section 3: Designing at Component Scale
Structural Patterns
Implementing the Decorator design patternGoalDesignProject – Adding behaviorsDecoratorADecoratorBProject – Decorator using ScrutorConclusionImplementing the Composite design patternGoalDesignProject – BookStoreConclusionImplementing the Adapter design patternGoalDesignProject – GreeterConclusionImplementing the Façade design patternGoalDesignProject – The façadesOpaque façadeTransparent façadeThe programFlexibility in actionAlternative façade patternsConclusionSummaryQuestionsFurther reading
Behavioral Patterns
Implementing the Template Method patternGoalDesignProject – Building a search machineConclusionImplementing the Chain of Responsibility patternGoalDesignProject – Message interpreterProject – Improved message interpreterProject – A final, finer-grained designConclusionSummaryQuestions
Understanding the Operation Result Design Pattern
The Operation Result patternGoalDesignProject – Implementing different Operation Result patternsThe consumerThe simplest form of the Operation Result patternA single error messageAdding a return valueMultiple error messagesAdding message severitySub-classes and factoriesAdvantages and disadvantagesAdvantagesDisadvantagesSummaryQuestionsFurther reading
Section 4: Designing at Application Scale
Understanding Layering
Introducing layeringClassic layering modelSplitting the layersLayers versus tiers versus assembliesWhat is an assembly?Responsibilities of the common layersPresentationDomainRich domain modelAnemic domain modelService layerDataRepository patternUnit of Work patternAbstract layersSharing the modelClean ArchitectureImplementing layering in real lifeTo be or not to be a purist?Building a façade over a database SummaryQuestionsFurther reading
Getting Started with Object Mappers
Object mapperGoalDesignProject – MapperCode smell – Too many dependenciesPattern – Aggregate ServicesPattern – Mapping FaçadeProject – Mapping serviceProject – AutoMapperConclusionSummaryQuestionsFurther reading
Mediator and CQRS Design Patterns
A high-level overview of Vertical Slice ArchitectureImplementing the Mediator patternGoalDesignProject – Mediator (IMediator)Project – Mediator (IChatRoom)ConclusionImplementing the CQRS patternGoalDesignProject – CQRSCode smell – Marker InterfacesMetadataDependency identifierConclusionUsing MediatR as a mediatorProject – Clean Architecture with MediatRConclusionSummaryQuestionsFurther reading
Getting Started with Vertical Slice Architecture
Vertical Slice ArchitectureWhat are the advantages and disadvantages?Anti-pattern – Big Ball of MudProject – Vertical Slice ArchitectureProject organizationExploring a featureRequest validationTestingContinuing your journeyConclusionSummaryQuestionsFurther reading
Introduction to Microservices Architecture
What are microservices?Cohesive unit of businessOwnership of dataMicroservice independenceAn introduction to event-driven architectureDomain eventsIntegration eventsApplication eventsEnterprise eventsConclusionGetting started with message queuesConclusionImplementing the Publish-Subscribe patternMessage brokersThe event sourcing patternExampleConclusionIntroducing Gateway patternsGateway Routing patternGateway Aggregation patternBackends for Frontends patternMixing and matching gatewaysConclusionRevisiting the CQRS patternConclusionExploring the Microservice Adapter patternAdapting an existing system to anotherDecommissioning a legacy applicationAdapting an event broker to anotherConclusionSummaryQuestionsFurther reading
Section 5: Designing the Client Side
ASP.NET Core User Interfaces
Getting familiar with Razor PagesDesignRoutingConclusionOrganizing the user interfacePartial viewsProject – Shared formConclusionTag HelpersBuilt-in Tag HelpersCreating a custom Tag HelperCreating an RSS feed TagHelperComponentConclusionView componentsProject – Reusable employee countConclusionDisplay and editor templatesDisplay templatesEditor templatesProject – Composite BookStore revisitedConclusionSummaryQuestionsFurther reading
A Brief Look into Blazor
Overview of Blazor ServerOverview of Blazor WebAssemblyGetting familiar with Razor componentsCreating Razor componentsC#-only componentsRazor-only componentsRazor and C# hybrid componentsCSS isolationComponent life cycleEvent handlingThe Model-View-Update patternGoalDesignProject – CounterConclusionA medley of Blazor featuresSummaryQuestionsFurther readingAn end is simply a new beginning
Appendices
Appendix A
Older C# featuresThe 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 statementsTarget-typed new expressionsInit-only propertiesRecord classesSimplifying the record creationThe with keywordDeconstructionEquality comparisonConclusionWhat’s new in .NET 6 and C# 10?File-scoped namespacesGlobal using directivesImplicit using directivesConstant interpolated stringsRecord structMinimal hosting modelMinimal APIsNullable reference types
Appendix B
An overview of containersDockerDocker ComposeOrchestrationProject TyeKubernetesScalingSummaryFurther reading
Assessment Answers
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12Chapter 13Chapter 14Chapter 15Chapter 16Chapter 17Chapter 18
Acronyms Lexicon
Other Books You May Enjoy
Index

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

3 Architectural Principles

This chapter focuses on fundamental architectural principles. The reason behind this is simple: those principles are the foundation of modern software engineering. Moreover, we apply these principles throughout the book to make sure that we write better code and make better design decisions by the end.

In this chapter, we cover the following topics:

The SOLID principles and their importance
The separation of concerns principle
The DRY principle
The KISS principle

The SOLID principles

SOLID is an acronym representing five principles that extend the basic OOP concepts of Abstraction, Encapsulation, Inheritance, and Polymorphism. They add more details about what to do and how to do it, guiding developers toward more ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

An Atypical ASP.NET Core 5 Design Patterns Guide

Publisher Resources

ISBN: 9781803249841

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

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

by Marcotte

3

Architectural Principles

The SOLID principles

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.