book

Apps and Services with .NET 8 - Second Edition

Name: Apps and Services with .NET 8 - Second Edition
Author: Mark J. Price
ISBN: 9781837637133

by Mark J. Price

December 2023

Intermediate to advanced

798 pages

17h 52m

English

Packt Publishing

Read now

Unlock full access

Preface
Where to find the code solutionsWhat this book coversWhat you need for this bookGet in touch
Introducing Apps and Services with .NET
Introducing this book and its contentsCompanion books to continue your learning journeyWhat you will learn in this bookMy learning philosophyFixing my mistakesFinding the solution code on GitHubProject naming and port numbering conventionsTreating warnings as errorsApp and service technologiesUnderstanding .NETBuilding websites and apps using ASP.NET CoreBuilding web and other servicesWindows Communication FoundationCommon service principlesSummary of choices for servicesBuilding Windows-only appsUnderstanding legacy Windows application platformsUnderstanding modern .NET support for legacy Windows platformsBuilding cross-platform mobile and desktop apps.NET MAUI alternativesUnderstanding the Uno platformUnderstanding AvaloniaSetting up your development environmentChoosing the appropriate tool and application type for learningUsing Visual Studio 2022 for general developmentUsing Visual Studio Code for cross-platform developmentUsing GitHub Codespaces for development in the cloudWhat I usedJetBrains Rider and its warnings about boxingDeploying cross-platformDownloading and installing Visual Studio 2022Visual Studio 2022 keyboard shortcutsDownloading and installing Visual Studio CodeInstalling other extensionsManaging Visual Studio Code extensions at the command promptUnderstanding Microsoft Visual Studio Code versionsVisual Studio Code keyboard shortcutsConsuming Azure resourcesUsing other project templatesInstalling additional template packsExploring top-level programs, functions, and namespacesWhat is automatically generated for a local function?Writing static functions in a separate Program class fileWhat is automatically generated for a static function?Making good use of the GitHub repository for this bookRaising issues with the bookGiving me feedbackDownloading solution code from the GitHub repositoryWhere to go for helpReading documentation on Microsoft LearnGetting help for the dotnet toolAI tools like ChatGPT and GitHub CopilotChatGPTGitHub CopilotSubscribing to the official .NET blog and announcementsPracticing and exploringExercise 1.1 – Test your knowledgeExercise 1.2 – Review the online-only sectionsExercise 1.3 – Explore topicsSummary
Managing Relational Data Using SQL Server
Understanding modern databasesUsing a sample relational databaseConnecting to a SQL Server databaseInstalling and setting up SQL Server locallyInstalling SQL Server Developer Edition for WindowsVisual Studio Code extension for working with SQL ServerCreating the Northwind sample database locallySetting up Azure SQL DatabaseJetBrains Rider tool window for working with SQL ServerCreating the Northwind sample database in the cloudManaging data with Transact-SQLT-SQL data typesDocumenting with commentsDeclaring variablesSpecifying data typesControlling flowOperatorsData Manipulation Language (DML)DML for adding, updating, and deleting dataData Definition Language (DDL)Managing data with low-level APIsUnderstanding the types in ADO.NETUnderstanding the types in ADO.NETCreating a console app for working with ADO.NETExecuting queries and working with data readers using ADO.NETOutputting statisticsWorking with ADO.NET asynchronouslyExecuting stored procedures using ADO.NETOutputting streams with a data readerGenerating objects with a data readerManaging data with DapperDapper connection extension methodsQuerying using DapperCleaning up data resourcesRemoving Azure resourcesPracticing and exploringExercise 2.1 – Test your knowledgeExercise 2.2 – Explore topicsExercise 2.3 – Alternatives for storing secretsSummary
Building Entity Models for SQL Server Using EF Core
Managing data with EF CoreUnderstanding Entity Framework CoreScaffolding models using an existing databaseSetting up the dotnet-ef toolDefining EF Core modelsUsing EF Core conventions to define the modelUsing EF Core annotation attributes to define the modelUsing the EF Core Fluent API to define the modelUnderstanding data seeding with the Fluent APIDefining the Northwind database modelQuerying the Northwind modelControlling the tracking of entitiesA scenario using default trackingThe same scenario using no trackingThe same scenario using no tracking with identity resolutionSummary of trackingMapping inheritance hierarchies with EF CoreTable-per-hierarchy (TPH) mapping strategyTable-per-type (TPT) mapping strategyTable-per-concrete-type (TPC) mapping strategyConfiguring inheritance hierarchy mapping strategiesExample of hierarchy mapping strategiesBuilding a reusable entity data modelCreating a class library for entity models using SQL ServerCreating a class library for the data context using SQL ServerCalculated properties on entity creationCreating a test project to check the integration of the class librariesWriting unit tests for entity modelsRunning unit tests using Visual Studio 2022Running unit tests using Visual Studio CodePracticing and exploringExercise 3.1 – Test your knowledgeExercise 3.2 – Practice benchmarking ADO.NET against EF CoreExercise 3.3 – Review performance choicesExercise 3.4 – Explore topicsSummary
Managing NoSQL Data Using Azure Cosmos DB
Understanding NoSQL databasesCosmos DB and its APIsDocument modelingConsistency levelsHierarchy of componentsThroughput provisioningPartition strategiesData storage designMigrating data to Cosmos DBCreating Cosmos DB resourcesUsing an emulator on Windows to create Azure Cosmos DB resources Using the Azure portal to create Azure Cosmos DB resourcesUsing a .NET app to create Azure Cosmos DB resourcesManipulating data with the Core (SQL) APIPerforming CRUD operations with the Cosmos SQL APIUnderstanding SQL queriesExploring other SQL queries with Cosmos DBExploring server-side programmingImplementing user-defined functionsImplementing stored proceduresCleaning up Azure resourcesPracticing and exploringExercise 4.1 – Test your knowledgeExercise 4.2 – Practice data modeling and partitioningExercise 4.3 – Explore topicsExercise 4.4 – Download cheat sheetsExercise 4.5 – Explore the Gremlin API for Cosmos DBExercise 4.6 – Explore NoSQL databasesSummary
Multitasking and Concurrency
Understanding processes, threads, and tasksRunning tasks asynchronouslyRunning multiple actions synchronouslyRunning multiple actions asynchronously using tasksStarting tasksWaiting for tasksUsing wait methods with tasksContinuing with another taskNested and child tasksWrapping tasks around other objectsSynchronizing access to shared resourcesAccessing a resource from multiple threadsApplying a mutually exclusive lock to a conchUnderstanding the lock statementAvoiding deadlocksSynchronizing eventsMaking CPU operations atomicApplying other types of synchronizationUnderstanding async and awaitImproving responsiveness for console appsWorking with async streamsImproving responsiveness for GUI appsImproving scalability for web applications and web servicesCommon types that support multitaskingUsing await in catch blocksPracticing and exploringExercise 5.1 – Test your knowledgeExercise 5.2 – Explore topicsExercise 5.3 – Read more about parallel programmingSummary
Using Popular Third-Party Libraries
Which third-party libraries are most popular?What is covered in my booksWorking with imagesGenerating grayscale thumbnailsImageSharp packages for drawing and the webWorking with text and numbers using HumanizerWorking with textHumanizer case transformationsHumanizer spacing conversionsHumanizer’s Singularize and Pluralize methodsExploring text manipulations with a console appWorking with numbersWorking with dates and timesLogging with SerilogStructured event dataSerilog sinksLogging to the console and a rolling file with SerilogMapping between objectsDefining models for an AutoMapper configurationDefining mappers for an AutoMapper configurationPerforming tests for an AutoMapper configurationPerforming live mappings between modelsMaking fluent assertions in unit testingMaking assertions about stringsMaking assertions about collections and arraysMaking assertions about dates and timesValidating dataUnderstanding the built-in validatorsPerforming custom validationCustomizing validation messagesDefining a model and validatorTesting the validatorValidating data with ASP.NET CoreGenerating PDFsUsing QuestPDF on Apple silicon MacsCreating class libraries to generate PDF documentsCreating a console app to generate PDF documentsPracticing and exploringExercise 6.1 – Test your knowledgeExercise 6.2 – Explore topicsSummary
Handling Dates, Times, and Internationalization
Working with dates and timesSpecifying date and time valuesFormatting date and time valuesDate and time calculationsMicroseconds and nanosecondsGlobalization with dates and timesComplexities of Daylight Saving Time (DST)Localizing the DayOfWeek enumWorking with only a date or a timeGetting date/time formatting informationUnit testing with a time providerWorking with time zonesUnderstanding DateTime and TimeZoneInfoExploring DateTime and TimeZoneInfoWorking with culturesDetecting and changing the current cultureTemporarily using the invariant cultureLocalizing your user interfaceDefining and loading resourcesTesting globalization and localizationWorking with Noda TimeImportant concepts and defaults in Noda TimeConverting between Noda Time date/time typesExploring Node Time in a console appUnit testing and JSON serialization with Noda TimePracticing and exploringExercise 7.1 – Test your knowledgeExercise 7.2 – Explore topicsExercise 7.3 – Learn from expert Jon SkeetSummary
Building and Securing Web Services Using Minimal APIs
Building web services using ASP.NET Core Minimal APIsBenefits of Minimal API-based web servicesUnderstanding Minimal API route mappingsUnderstanding parameter mappingUnderstanding return valuesDocumenting a Minimal APIs serviceSetting up an ASP.NET Core Web API projectTesting web services using SwaggerTesting web services with code editor toolsExcluding paths from OpenAPI documentationVisual Studio 2022 scaffolding for Minimal APIsRelaxing the same origin security policy using CORSConfiguring HTTP logging for the web serviceCreating a web page JavaScript clientCreating a .NET clientUnderstanding CORSEnabling CORS for specific endpointsUnderstanding other CORS policy optionsPreventing denial of service attacks using rate limitingRate limiting using the AspNetCoreRateLimit packageCreating a rate-limited console clientRate limiting using ASP.NET Core middlewareImproving startup time and resources using native AOTLimitations of native AOTReflection and native AOTNative AOT for ASP.NET CoreRequirements for native AOTEnabling native AOT for a projectEnabling JSON serialization with native AOTBuilding a native AOT projectPublishing a native AOT projectUnderstanding identity servicesJWT bearer authorizationAuthenticating service clients using JWT bearer authenticationPracticing and exploringExercise 8.1 – Test your knowledgeExercise 8.2 – Review Microsoft HTTP API design policyExercise 8.3 – Explore topicsExercise 8.4 – Exposing data via the web using OData servicesExercise 8.5 – Auth0 project templatesSummary
Caching, Queuing, and Resilient Background Services
Understanding service architectureWhat parts of a system are slowest?Numbers every (developer) should knowCaching with ASP.NET CoreGeneral caching guidelinesBuilding a controller-based Web API serviceCaching objects using in-memory cachingCaching objects using distributed cachingA new abstraction for distributed cachingCaching web responses using HTTP cachingFault tolerance with PollyUnderstanding retry and circuit breaker patternsDefining and executing policiesDefining wait intervals between retriesApplying policies to HTTP clientsAdding random faults to the web serviceBuilding an MVC project to call the faulty web serviceImplementing the Retry pattern for transient fault handlingQueuing with RabbitMQSetting up RabbitMQ using DockerSending messages to a queue using an MVC websiteConsuming message from a queue using a console appImplementing long-running background servicesBuilding a worker serviceProcessing queued message using a worker serviceExecuting code on a timed scheduleBuilding a website to host HangfireScheduling jobs using HangfirePracticing and exploringExercise 9.1 – Test your knowledgeExercise 9.2 – Explore topicsExercise 9.3 – Replace the Distributed Memory Cache with another distributed cache implementationExercise 9.4 – Replace Hangfire with Quartz.NETExercise 9.5 – Review the Reliable Web App patternSummary

Building Serverless Nanoservices Using Azure Functions
Understanding Azure FunctionsAzure Functions triggers and bindingsNCRONTAB expressionsAzure Functions versions and languagesAzure Functions worker modelsAzure Functions hosting plansAzure Storage requirementsTesting locally with AzuriteAzure Functions authorization levelsAzure Functions support for dependency injectionInstalling Azure Functions Core ToolsBuilding an Azure Functions projectUsing Visual Studio 2022Using Visual Studio CodeUsing the func CLIReviewing the Azure Functions projectImplementing a simple functionTesting a simple functionResponding to timer and resource triggersImplementing a Timer triggered functionTesting the Timer triggered functionImplementing a function that works with queues and BLOBsTesting the function that works with queues and BLOBsPublishing an Azure Functions project to the cloudUsing Visual Studio 2022 to publishUsing Visual Studio Code to publishCleaning up Azure Functions resourcesPracticing and exploringExercise 10.1 – Test your knowledgeExercise 10.2 – Explore topicsSummary
Broadcasting Real-Time Communication Using SignalR
Understanding SignalRThe history of real-time communication on the webAJAXWebSocketIntroducing SignalRAzure SignalR ServiceDesigning method signaturesBuilding a live communication service using SignalRDefining some shared modelsEnabling a server-side SignalR hubBuilding a web client using the SignalR JavaScript libraryAdding a chat page to the MVC websiteTesting the chat featureBuilding a .NET console app clientCreating a .NET client for SignalRTesting the .NET console app clientStreaming data using SignalRDefining a hub for streamingCreating a .NET console app client for streamingTesting the streaming service and clientPracticing and exploringExercise 11.1 – Test your knowledgeExercise 11.2 – Explore topicsSummary
Combining Data Sources Using GraphQL
Understanding GraphQLGraphQL query document formatRequesting fieldsSpecifying filters and argumentsUnderstanding other GraphQL capabilitiesUnderstanding the ChilliCream GraphQL platformBuilding a service that supports GraphQLDefining the GraphQL schema for Hello WorldWriting and executing GraphQL queriesNaming GraphQL queries aka operationsUnderstanding field conventionsDefining GraphQL queries for EF Core modelsAdding support for EF CoreExploring GraphQL queries with NorthwindImplementing paging supportImplementing filtering supportImplementing sorting supportBuilding .NET clients for a GraphQL serviceChoosing GraphQL request formatsUnderstanding the GraphQL response formatUsing REST Client as a GraphQL clientUsing an ASP.NET Core MVC project as a GraphQL clientTesting the .NET clientCreating a console app client using Strawberry ShakeImplementing GraphQL mutationsAdding mutations to the GraphQL serviceExploring the add product mutationImplementing updates and deletes as mutationsImplementing GraphQL subscriptionsAdding a subscription and topic to the GraphQL serviceExploring subscribing to a topicPracticing and exploringExercise 12.1 – Test your knowledgeExercise 12.2 – Explore topicsExercise 12.3 – Practice building .NET clientsSummary
Building Efficient Microservices Using gRPC
Understanding gRPCHow gRPC worksDefining gRPC contracts with .proto filesgRPC benefitsgRPC limitationsTypes of gRPC methodsMicrosoft’s gRPC packagesBuilding a gRPC service and clientBuilding a Hello World gRPC serviceProject file item configurationBuilding a Hello World gRPC clientTesting a gRPC service and clientImplementing gRPC for an EF Core modelImplementing the gRPC serviceImplementing the gRPC clientTaking gRPC furtherImproving a gRPC service with native AOT publishGetting request and response metadataAdding a deadline for higher reliabilityHandling dates, times, and decimal numbersDefining a custom decimal type and using date/time typesImplementing the product and employee gRPC servicesAdding product and employee gRPC clientsTesting decimal, date, and bytes handlingImplementing interceptors and handling faultsAdding a client-side interceptorException and transient fault handlingImplementing gRPC JSON transcodingEnabling gRPC JSON transcodingTesting gRPC JSON transcodingComparing with gRPC-WebPracticing and exploringExercise 13.1 – Test your knowledgeExercise 13.2 – Compare gRPC services with HTTP APIsExercise 13.3 – Explore topicsSummary
Building Web User Interfaces Using ASP.NET Core
Setting up an ASP.NET Core MVC websiteCreating an ASP.NET Core MVC websiteExploring the default ASP.NET Core MVC websiteUnderstanding visitor registrationReviewing an MVC website project structureReferencing an EF Core class library and registering a data contextDefining web user interfaces with Razor views Understanding Razor viewsPrototyping with BootstrapUnderstanding Razor syntax and expressionsUnderstanding HTML Helper methodsDefining a strongly-typed Razor viewLocalizing and globalizing with ASP.NET CoreCreating resource filesIf you are using Visual Studio 2022If you are using Visual Studio CodeLocalizing Razor views with an injected view localizerUnderstanding the Accept-Language headerDefining web user interfaces with Tag HelpersComparing HTML Helpers and Tag HelpersExploring the Anchor Tag HelperExploring the Cache Tag HelpersExploring the Environment Tag HelperUnderstanding how cache busting with Tag Helpers worksExploring Forms-related Tag HelpersOutput cachingOutput caching endpointsOutput caching MVC viewsPracticing and exploringExercise 14.1 – Test your knowledgeExercise 14.2 – Practice building user interfaces with BoostrapExercise 14.3 – Explore topicsSummary
Building Web Components Using Blazor
Understanding BlazorBlazor hosting modelsBlazor componentsBlazor routing to page componentsHow to pass route parametersSetting parameters from a query stringRoute constraints for parametersBase component classesBlazor layoutsHow to navigate Blazor routes to page componentsCSS and JavaScript isolationBuilding Blazor componentsReviewing the new Blazor project templateUsing Bootstrap iconsReferencing an EF Core class library and registering a data contextBuilding a static server rendered component for dataBuilding a component with server interactivityBuilding a Blazor progress bar componentBuilding a Blazor dialog box componentBuilding a Blazor alert componentBuilding a Blazor data componentMaking the componentMaking the component a routable page componentGetting entities into a component by building a web serviceGetting entities into a component by calling the web servicePracticing and exploringExercise 15.1 – Test your knowledgeExercise 15.2 – Practice building Blazor componentsExercise 15.3 – Practice building an IndexedDB interop serviceExercise 15.4 – Explore topicsExercise 15.5 – Explore Blazor WebAssembly topicsExercise 15.6 – Explore Progressive Web Apps with BlazorExercise 15.7 – Leveraging Open Source Blazor Component LibrariesSummary
Building Mobile and Desktop Apps Using .NET MAUI
Understanding XAMLSimplifying code using XAML.NET MAUI namespacesType convertersChoosing between .NET MAUI controlsMarkup extensionsUnderstanding .NET MAUI.NET MAUI and Xamarin supportDevelopment tools for mobile first, cloud firstInstalling .NET MAUI workloads manually.NET MAUI user interface component categoriesShell controlListView controlEntry and Editor controls.NET MAUI handlersWriting platform-specific codeBuilding mobile and desktop apps using .NET MAUICreating a virtual Android device for local app testingEnabling Windows developer modeCreating a .NET MAUI projectAdding shell navigation and more content pagesImplementing more content pagesUsing shared resourcesDefining resources to share across an appReferencing shared resourcesChanging shared resources dynamicallyUsing data bindingBinding to elementsPracticing and exploringExercise 16.1 – Test your knowledgeExercise 16.2 – Explore topicsExercise 16.3 – Implementing Model-View-ViewModel for .NET MAUIExercise 16.4 – Integrating .NET MAUI apps with Blazor and native platformsSummary
Epilogue
Cloud-native development using .NET AspireIntroducing the Survey Project ChallengeThird edition coming in December 2025Next steps on your C# and .NET learning journeyCompanion books to continue your learning journeyOther books to take your learning furtherGood luck!
Index

Overview

Apps and Services with .NET 8 is an in-depth guide for experienced developers eager to advance their skills in building robust applications and services using .NET technologies. With step-by-step projects, comprehensive guidance on modern tools such as Blazor and .NET MAUI, and practical solutions for real-world challenges, this book serves as your definitive resource for professional .NET development.

What this Book will help me do

Master the implementation of services using gRPC and GraphQL technologies to enable scalable systems.
Discover best practices for integrating cloud-native data stores like Cosmos DB for enhanced flexibility.
Explore techniques in Blazor Full Stack and .NET MAUI to create modern, portable applications.
Learn to implement third-party libraries like Serilog and FluentValidation to improve application functionality.
Understand strategies for designing efficient services with caching, queuing, and background processes.

Author(s)

Mark J. Price is an experienced software developer and technical author known for his clear and engaging writing style. With years of hands-on experience in .NET development, he combines his deep understanding of the framework with a passion for helping developers grow their technical expertise. Mark's approachable framework ensures readers gain both knowledge and confidence in their .NET journey.

Who is it for?

This book is crafted for experienced .NET developers aiming to expand their expertise in crafting modern enterprise-grade applications and services. Ideal for developers knowledgeable in C# and .NET, this material will help refine their skills with specialized libraries and tools. You'll find this book valuable if you're interested in scalable, cloud-ready application architecture. It's a great next step after mastering the fundamentals of .NET.

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

Building Modern SaaS Applications with C# and .NET

Publisher Resources

ISBN: 9781837637133

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills