book

Architecting ASP.NET Core Applications - Third Edition

Name: Architecting ASP.NET Core Applications - Third Edition
Author: Carl-Hugo Marcotte
ISBN: 9781805123385

by Carl-Hugo Marcotte

March 2024

Intermediate to advanced

806 pages

19h 50m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touch
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 StandardThe command-line interface versus Visual Studio Code versus Visual StudioAn overview of project templatesRunning and building your programTechnical requirementsSummaryQuestionsFurther readingAnswers
Automated Testing
An overview of automated testingUnit testingIntegration testingEnd-to-end testingOther types of testsFinding the right balanceEnhancing code qualityImproving quality with refactoringManaging technical debtTesting approachesTDDATDDBDDTesting techniquesWhite-box testingBlack-box testingGray-box testingWhite-box vs. black-box vs. gray-box testingConclusionTest case creationEquivalence partitioningBoundary value analysisDecision table testingState transition testingUse case testingIntroducing the xUnit frameworkHow to create an xUnit test projectKey xUnit featuresFactAttributeAssertionsTheoryAttributeFixtureArrange, Act, AssertOrganizing your testsUnit testsNamespacesTest class namesTest code inside the test classIntegration testsWriting ASP.NET Core integration testsClassic web applicationMinimal hostingWorkaroundAlternative to using fixturesCreating a reusable test applicationImportant testing principlesSummaryQuestionsFurther readingAnswers
Architectural Principles
Separation of concerns (SoC)Don’t repeat yourself (DRY)Keep it simple, stupid (KISS)You Aren’t Gonna Need It (YAGNI)The SOLID principlesSingle responsibility principle (SRP)Project – Single ResponsibilityOpen/closed principle (OCP)Project – Open CloseLiskov substitution principle (LSP)The LSP explainedCovariance and contravarianceProject – Liskov SubstitutionConclusionInterface segregation principle (ISP)What is an interface?Project – Interface SegregationConclusionDependency inversion principle (DIP)Direct dependencyInverted dependencyDirect subsystems dependencyInverted subsystems dependencyProject – Dependency inversionConclusionSummaryQuestionsFurther readingAnswers
REST APIs
REST and HTTPHTTP methodsHTTP status codesHTTP headersVersioningDefault versioning strategyVersioning strategyWrapping upThe Data Transfer Object (DTO) patternGoalDesignConceptual examplesRegistering for an activityFetching activity registration detailsConclusionAPI contractsCode-first API contractThe first endpointThe second endpointWrapping upSummaryQuestionsFurther readingAnswers
Section 2: Designing with ASP.NET Core
Minimal APIs
Top-level statementsMinimal hostingMinimal APIsMapping a route to a delegateConfiguring endpointsInputsOutputsMetadataConfiguring JSON serializationLeveraging endpoint filtersLeveraging the endpoint filter factoryOrganizing endpointsMapGroupCreating a custom Map extension methodClass librariesUsing Minimal APIs with Data Transfer ObjectsGoalDesignProject – Minimal APIRaw CRUD endpointsDTO-enabled endpointsConclusionSummaryQuestionsFurther readingAnswers
Model-View-Controller
The MVC design patternGoalDesignAnatomy of ASP.NET Core web APIsThe entry pointDirectory structureControllerReturning valuesAttribute routingConclusionUsing MVC with DTOsGoalDesignProject – MVC APIRaw CRUD controllerDTO controllerConclusionSummaryQuestionsFurther readingAnswers
Strategy, Abstract Factory, and Singleton Design Patterns
The Strategy design patternGoalDesignProject – StrategyConclusionThe Abstract Factory design patternGoalDesignProject – Abstract FactoryProject – the mid-range vehicle factoryImpacts of the Abstract FactoryConclusionThe Singleton design patternGoalDesignAn alternative (better) wayCode smell – Ambient ContextConclusionSummaryQuestionsAnswers

Dependency Injection
What is dependency injection?The composition rootStriving for adaptabilityUnderstanding the use of the IoC containerThe role of an IoC containerCode smell – Control FreakStable dependenciesVolatile dependenciesConclusionObject lifetimeWhat’s an object’s lifetime? .NET object lifetimeRegistering our dependenciesRegistering your features elegantlyProject – Registering the demo featureUsing external IoC containersRevisiting the Strategy patternConstructor injectionProperty injectionMethod injectionProject – StrategyShared building blocksControl Freak controllersInjecting an implementation in the controllersInjecting an abstraction in the controllerConstructing the InjectAbstractionLocationsControllerConclusionRevisiting the Singleton patternProject – Application stateFirst implementationSecond implementationUsing the implementationsProject – WishlistConclusionUnderstanding guard clausesUnderstanding the Service Locator patternProject – ServiceLocatorImplementing method injectionImplementing constructor injectionImplementing a minimal APIConclusionRevisiting the Factory patternProject – FactorySummaryQuestionsFurther readingAnswers
Application Configuration and the Options Pattern
Loading the configurationLearning the options interfacesIOptionsMonitor<TOptions>IOptionsFactory<TOptions>IOptionsSnapshot<TOptions>IOptions<TOptions>Exploring common usage scenariosManual configurationUsing the settings fileInjecting optionsNamed optionsIOptionsFactory<MyOptions>IOptionsMonitor<MyOptions>IOptionsSnapshot<MyOptions>Bind options to an existing objectReloading options at runtimeLearning options configurationCreating the programConfiguring the optionsImplementing a configurator objectAdding post-configurationUsing multiple configurator objectsExploring other configuration possibilitiesValidating our options objectsEager validationData annotationsValidation typesValidating options using FluentValidationInjecting options objects directly Centralizing the configuration for easier managementUsing the configuration-binding source generatorUsing the options validation source generatorUsing the ValidateOptionsResultBuilder classWrapping upSummaryQuestionsFurther readingAnswers
Logging Patterns
What is logging?Writing logsLog levelsLogging providersConfiguring loggingStructured loggingSummaryQuestionsFurther readingAnswers
Section 3: Component Patterns
Structural Patterns
The Decorator design patternGoalDesignProject – Adding behaviorsDecoratorADecoratorBProject – Decorator using ScrutorConclusionThe Composite design patternGoalDesignProject – BookStoreConclusionThe Adapter design patternGoalDesignProject – GreeterConclusionThe Façade design patternGoalDesignProject – The façadesOpaque façadeTransparent façadeThe programFlexibility in actionAlternative façade patternsConclusionSummaryQuestionsFurther readingAnswers
Behavioral Patterns
The Template Method patternGoalDesignProject – Building a search machineUnit testsConclusionThe Chain of Responsibility patternGoalDesign Project – Message interpreterConclusionMixing the Template Method and Chain of Responsibility patternsProject – Improved message interpreterProject – A final, finer-grained designConclusionSummaryQuestionsAnswers
Operation Result Pattern
The Operation Result patternGoalDesignProject – Implementing different Operation Result patternsThe Program.cs fileThe simplest form of the Operation Result patternA single error messageAdding a return valueMultiple error messagesAdding message severitySub-classes and factoriesProject – Registration ApplicationAdvantages and disadvantagesAdvantagesDisadvantagesConclusionSummaryQuestionsFurther readingAnswers
Section 4: Application Patterns
Anti-pattern – Big Ball of Mud
Layering and Clean Architecture
Introducing layeringClassic layering modelSplitting the layersLayers versus tiers versus assembliesWhat is a tier?What is a layer?What is an assembly?Responsibilities of the common layersPresentationDomainRich domain modelAnemic domain modelThe Service layerDataOverview of the Repository patternOverview of the Unit of Work patternAbstract layersSharing the modelClean ArchitectureImplementing layering in real lifeTo be or not to be a purist?Building a façade over a databaseSummaryQuestionsFurther readingAnswers
Object Mappers
The Object Mapper patternGoalDesignProject – MapperConclusionCode smell – too many dependenciesOverview of the Aggregate Services patternImplementing a mapping façadeImplementing a mapping serviceExploring AutoMapperProject – AutoMapperExploring MapperlyProject – MapperlySummaryQuestionsFurther readingAnswers
Mediator and CQS Patterns
A high-level overview of Vertical Slice ArchitectureThe Mediator patternGoalDesignProject – Mediator (IMediator)Project – Mediator (IChatRoom)ConclusionThe CQS patternGoalDesignProject – CQSConclusionCode smell – Marker InterfacesMetadataDependency identifierUsing MediatR as a mediatorProject – Clean Architecture with MediatRSummaryQuestionsFurther readingAnswers
Getting Started with Vertical Slice Architecture
Vertical Slice ArchitectureWhat are the advantages and disadvantages?AdvantagesDisadvantagesDownsides or upsides?Project – Vertical Slice ArchitectureProject organizationExploring a featureTestingContinuing your journey – a few tips and tricksAgile and DevOps synergyConclusionSummaryQuestionsFurther readingAnswers
Request-EndPoint-Response (REPR)
The Request-EndPoint-Response (REPR) patternGoalDesignProject – SimpleEndpointFeature: ShuffleTextFeature: RandomNumberFeature: UpperCaseConclusionAn e-commerce application—a slice of the real-worldAssembling our stackDissecting the code structureExploring the shopping basketAddItem featureManaging exception handlingCreating an exception handler middlewareException handling using ExceptionMapperLeveraging exceptions to propagate errorsGray-box testingAddItemTestSummaryQuestionsFurther readingAnswers
Introduction to Microservices Architecture
What are microservices?Cohesive unit of businessOwnership of dataMicroservice independenceAn introduction to Event-Driven ArchitectureTypes of eventsDomain eventsIntegration eventsApplication eventsEnterprise eventsGetting started with message queuesOverview of the Publish-Subscribe patternMessage brokersOverview of the Event Sourcing patternExampleConclusionIntroducing Gateway patternsOverview of the Gateway Routing patternOverview of the Gateway Aggregation patternOverview of the Backend for Frontend patternMixing and matching gatewaysConclusionProject – BFFLayering APIsAdvantages of a layered API designDisadvantages of a layered API designRunning the microservicesManually starting the projectsUsing Docker Compose to run the projectsBriefly testing the servicesCreating typed HTTP clients using RefitCreating a service that serves the current customerFeaturesFetching the catalogFetching the shopping cartManaging the shopping cartConclusionRevisiting the CQRS patternAdvantages and potential risksBenefits of the CQRS patternPotential risks of using the CQRS patternConclusionOverview of the Microservice Adapter pattern Adapting an existing system to anotherDecommissioning a legacy applicationAdapting an event broker to anotherConclusionSummaryQuestionsFurther readingAnswers
Modular Monolith
What is a Modular Monolith?What are traditional monoliths?What are microservices?Advantages of Modular MonolithsKey components of a Modular MonolithImplementing a Modular MonolithPlanning the projectAnalyzing the domainIdentifying the modulesIdentifying the interactions between modulesDefining our stackThe module structureThe URI spaceThe data spaceThe message brokerProject – Modular MonolithSending events from the catalog moduleConsuming the events from the basket moduleInside the aggregatorExploring the REST API HttpClientSending HTTP requests to the APIValidating the existence of a productTransitioning to microservicesChallenges and pitfallsSummaryQuestionsFurther readingAnswersAn end is simply a new beginning
Other Books You May Enjoy
Index

Content preview from Architecting ASP.NET Core Applications - Third Edition

12 Behavioral Patterns

This chapter explores two new design patterns from the well-known Gang of Four (GoF). They are behavioral patterns, meaning they help simplify system behavior management.

Often, we need to encapsulate some core algorithm while allowing other pieces of code to extend that implementation. That is where the Template Method pattern comes into play. Other times, we have a complex process with multiple algorithms that all apply to one or more situations, and we need to organize it in a testable and extensible fashion. This is where the Chain of Responsibility pattern can help.

In this chapter, we cover the following topics:

The Template Method pattern
The Chain of Responsibility pattern
Mixing the Template Method and Chain ...

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

Publisher Resources

ISBN: 9781805123385

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Architecting ASP.NET Core Applications - Third Edition

by Carl-Hugo Marcotte

12

Behavioral Patterns

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.