Apps and Services with .NET 8: Build practical projects with Blazor, .NET MAUI, gRPC, GraphQL, 2nd edition

Preface
   Where to find the code solutions
   What this book covers
   What you need for this book
   Get in touch
Introducing Apps and Services with .NET
   Introducing this book and its contents
      Companion books to continue your learning journey
      What you will learn in this book
      My learning philosophy
      Fixing my mistakes
      Finding the solution code on GitHub
      Project naming and port numbering conventions
      Treating warnings as errors
   App and service technologies
      Understanding .NET
      Building websites and apps using ASP.NET Core
      Building web and other services
      Windows Communication Foundation
      Common service principles
      Summary of choices for services
      Building Windows-only apps
         Understanding legacy Windows application platforms
         Understanding modern .NET support for legacy Windows platforms
      Building cross-platform mobile and desktop apps
      .NET MAUI alternatives
         Understanding the Uno platform
         Understanding Avalonia
   Setting up your development environment
      Choosing the appropriate tool and application type for learning
         Using Visual Studio 2022 for general development
         Using Visual Studio Code for cross-platform development
         Using GitHub Codespaces for development in the cloud
         What I used
         JetBrains Rider and its warnings about boxing
      Deploying cross-platform
      Downloading and installing Visual Studio 2022
         Visual Studio 2022 keyboard shortcuts
      Downloading and installing Visual Studio Code
         Installing other extensions
         Managing Visual Studio Code extensions at the command prompt
         Understanding Microsoft Visual Studio Code versions
         Visual Studio Code keyboard shortcuts
      Consuming Azure resources
      Using other project templates
   Installing additional template packs
   Exploring top-level programs, functions, and namespaces
      What is automatically generated for a local function?
      Writing static functions in a separate Program class file
      What is automatically generated for a static function?
   Making good use of the GitHub repository for this book
      Raising issues with the book
      Giving me feedback
      Downloading solution code from the GitHub repository
   Where to go for help
      Reading documentation on Microsoft Learn
      Getting help for the dotnet tool
      AI tools like ChatGPT and GitHub Copilot
         ChatGPT
         GitHub Copilot
      Subscribing to the official .NET blog and announcements
   Practicing and exploring
      Exercise 1.1 – Test your knowledge
      Exercise 1.2 – Review the online-only sections
      Exercise 1.3 – Explore topics
   Summary
Managing Relational Data Using SQL Server
   Understanding modern databases
      Using a sample relational database
      Connecting to a SQL Server database
      Installing and setting up SQL Server locally
         Installing SQL Server Developer Edition for Windows
         Visual Studio Code extension for working with SQL Server
         Creating the Northwind sample database locally
      Setting up Azure SQL Database
         JetBrains Rider tool window for working with SQL Server
         Creating the Northwind sample database in the cloud
   Managing data with Transact-SQL
      T-SQL data types
      Documenting with comments
      Declaring variables
      Specifying data types
      Controlling flow
      Operators
      Data Manipulation Language (DML)
      DML for adding, updating, and deleting data
      Data Definition Language (DDL)
   Managing data with low-level APIs
      Understanding the types in ADO.NET
   Creating a console app for working with ADO.NET
   Executing queries and working with data readers using ADO.NET
   Outputting statistics
   Working with ADO.NET asynchronously
   Executing stored procedures using ADO.NET
   Outputting streams with a data reader
   Generating objects with a data reader
   Managing data with Dapper
      Dapper connection extension methods
      Querying using Dapper
   Cleaning up data resources
      Removing Azure resources
   Practicing and exploring
      Exercise 2.1 – Test your knowledge
      Exercise 2.2 – Explore topics
      Exercise 2.3 – Alternatives for storing secrets
   Summary
Building Entity Models for SQL Server Using EF Core
   Managing data with EF Core
      Understanding Entity Framework Core
      Scaffolding models using an existing database
      Setting up the dotnet-ef tool
      Defining EF Core models
      Using EF Core conventions to define the model
      Using EF Core annotation attributes to define the model
      Using the EF Core Fluent API to define the model
      Understanding data seeding with the Fluent API
      Defining the Northwind database model
      Querying the Northwind model
      Controlling the tracking of entities
         A scenario using default tracking
         The same scenario using no tracking
         The same scenario using no tracking with identity resolution
         Summary of tracking
   Mapping inheritance hierarchies with EF Core
      Table-per-hierarchy (TPH) mapping strategy
      Table-per-type (TPT) mapping strategy
      Table-per-concrete-type (TPC) mapping strategy
      Configuring inheritance hierarchy mapping strategies
      Example of hierarchy mapping strategies
   Building a reusable entity data model
      Creating a class library for entity models using SQL Server
      Creating a class library for the data context using SQL Server
      Calculated properties on entity creation
      Creating a test project to check the integration of the class libraries
      Writing unit tests for entity models
      Running unit tests using Visual Studio 2022
      Running unit tests using Visual Studio Code
   Practicing and exploring
      Exercise 3.1 – Test your knowledge
      Exercise 3.2 – Practice benchmarking ADO.NET against EF Core
      Exercise 3.3 – Review performance choices
      Exercise 3.4 – Explore topics
   Summary
Managing NoSQL Data Using Azure Cosmos DB
   Understanding NoSQL databases
      Cosmos DB and its APIs
      Document modeling
      Consistency levels
      Hierarchy of components
      Throughput provisioning
      Partition strategies
      Data storage design
      Migrating data to Cosmos DB
   Creating Cosmos DB resources
      Using an emulator on Windows to create Azure Cosmos DB resources
      Using the Azure portal to create Azure Cosmos DB resources
      Using a .NET app to create Azure Cosmos DB resources
   Manipulating data with the Core (SQL) API
      Performing CRUD operations with the Cosmos SQL API
      Understanding SQL queries
      Exploring other SQL queries with Cosmos DB
   Exploring server-side programming
      Implementing user-defined functions
      Implementing stored procedures
   Cleaning up Azure resources
   Practicing and exploring
      Exercise 4.1 – Test your knowledge
      Exercise 4.2 – Practice data modeling and partitioning
      Exercise 4.3 – Explore topics
      Exercise 4.4 – Download cheat sheets
      Exercise 4.5 – Explore the Gremlin API for Cosmos DB
      Exercise 4.6 – Explore NoSQL databases
   Summary
Multitasking and Concurrency
   Understanding processes, threads, and tasks
   Running tasks asynchronously
      Running multiple actions synchronously
      Running multiple actions asynchronously using tasks
      Starting tasks
      Waiting for tasks
      Using wait methods with tasks
      Continuing with another task
      Nested and child tasks
      Wrapping tasks around other objects
   Synchronizing access to shared resources
      Accessing a resource from multiple threads
      Applying a mutually exclusive lock to a conch
      Understanding the lock statement
      Avoiding deadlocks
      Synchronizing events
      Making CPU operations atomic
      Applying other types of synchronization
   Understanding async and await
      Improving responsiveness for console apps
      Working with async streams
      Improving responsiveness for GUI apps
      Improving scalability for web applications and web services
      Common types that support multitasking
      Using await in catch blocks
   Practicing and exploring
      Exercise 5.1 – Test your knowledge
      Exercise 5.2 – Explore topics
      Exercise 5.3 – Read more about parallel programming
   Summary
Using Popular Third-Party Libraries
   Which third-party libraries are most popular?
      What is covered in my books
   Working with images
      Generating grayscale thumbnails
      ImageSharp packages for drawing and the web
   Working with text and numbers using Humanizer
      Working with text
      Humanizer case transformations
      Humanizer spacing conversions
      Humanizer’s Singularize and Pluralize methods
      Exploring text manipulations with a console app
      Working with numbers
      Working with dates and times
   Logging with Serilog
      Structured event data
      Serilog sinks
      Logging to the console and a rolling file with Serilog
   Mapping between objects
      Defining models for an AutoMapper configuration
      Defining mappers for an AutoMapper configuration
      Performing tests for an AutoMapper configuration
      Performing live mappings between models
   Making fluent assertions in unit testing
      Making assertions about strings
      Making assertions about collections and arrays
      Making assertions about dates and times
   Validating data
      Understanding the built-in validators
      Performing custom validation
      Customizing validation messages
      Defining a model and validator
      Testing the validator
      Validating data with ASP.NET Core
   Generating PDFs
      Using QuestPDF on Apple silicon Macs
      Creating class libraries to generate PDF documents
      Creating a console app to generate PDF documents
   Practicing and exploring
      Exercise 6.1 – Test your knowledge
      Exercise 6.2 – Explore topics
   Summary
Handling Dates, Times, and Internationalization
   Working with dates and times
      Specifying date and time values
      Formatting date and time values
      Date and time calculations
      Microseconds and nanoseconds
      Globalization with dates and times
      Complexities of Daylight Saving Time (DST)
      Localizing the DayOfWeek enum
      Working with only a date or a time
      Getting date/time formatting information
      Unit testing with a time provider
   Working with time zones
      Understanding DateTime and TimeZoneInfo
      Exploring DateTime and TimeZoneInfo
   Working with cultures
      Detecting and changing the current culture
      Temporarily using the invariant culture
      Localizing your user interface
      Defining and loading resources
      Testing globalization and localization
   Working with Noda Time
      Important concepts and defaults in Noda Time
      Converting between Noda Time date/time types
      Exploring Node Time in a console app
      Unit testing and JSON serialization with Noda Time
   Practicing and exploring
      Exercise 7.1 – Test your knowledge
      Exercise 7.2 – Explore topics
      Exercise 7.3 – Learn from expert Jon Skeet
   Summary
Building and Securing Web Services Using Minimal APIs
   Building web services using ASP.NET Core Minimal APIs
      Benefits of Minimal API-based web services
      Understanding Minimal API route mappings
      Understanding parameter mapping
      Understanding return values
      Documenting a Minimal APIs service
      Setting up an ASP.NET Core Web API project
      Testing web services using Swagger
      Testing web services with code editor tools
      Excluding paths from OpenAPI documentation
      Visual Studio 2022 scaffolding for Minimal APIs
   Relaxing the same origin security policy using CORS
      Configuring HTTP logging for the web service
      Creating a web page JavaScript client
      Creating a .NET client
      Understanding CORS
      Enabling CORS for specific endpoints
      Understanding other CORS policy options
   Preventing denial of service attacks using rate limiting
      Rate limiting using the AspNetCoreRateLimit package
      Creating a rate-limited console client
      Rate limiting using ASP.NET Core middleware
   Improving startup time and resources using native AOT
      Limitations of native AOT
      Reflection and native AOT
      Native AOT for ASP.NET Core
      Requirements for native AOT
      Enabling native AOT for a project
      Enabling JSON serialization with native AOT
      Building a native AOT project
      Publishing a native AOT project
   Understanding identity services
      JWT bearer authorization
      Authenticating service clients using JWT bearer authentication
   Practicing and exploring
      Exercise 8.1 – Test your knowledge
      Exercise 8.2 – Review Microsoft HTTP API design policy
      Exercise 8.3 – Explore topics
      Exercise 8.4 – Exposing data via the web using OData services
      Exercise 8.5 – Auth0 project templates
   Summary
Caching, Queuing, and Resilient Background Services
   Understanding service architecture
      What parts of a system are slowest?
      Numbers every (developer) should know
   Caching with ASP.NET Core
      General caching guidelines
      Building a controller-based Web API service
      Caching objects using in-memory caching
      Caching objects using distributed caching
      A new abstraction for distributed caching
      Caching web responses using HTTP caching
   Fault tolerance with Polly
      Understanding retry and circuit breaker patterns
      Defining and executing policies
      Defining wait intervals between retries
      Applying policies to HTTP clients
      Adding random faults to the web service
      Building an MVC project to call the faulty web service
      Implementing the Retry pattern for transient fault handling
   Queuing with RabbitMQ
      Setting up RabbitMQ using Docker
      Sending messages to a queue using an MVC website
      Consuming message from a queue using a console app
   Implementing long-running background services
      Building a worker service
      Processing queued message using a worker service
      Executing code on a timed schedule
      Building a website to host Hangfire
      Scheduling jobs using Hangfire
   Practicing and exploring
      Exercise 9.1 – Test your knowledge
      Exercise 9.2 – Explore topics
      Exercise 9.3 – Replace the Distributed Memory Cache with another distributed cache implementation
      Exercise 9.4 – Replace Hangfire with Quartz.NET
      Exercise 9.5 – Review the Reliable Web App pattern
   Summary
Building Serverless Nanoservices Using Azure Functions
   Understanding Azure Functions
      Azure Functions triggers and bindings
      NCRONTAB expressions
      Azure Functions versions and languages
      Azure Functions worker models
      Azure Functions hosting plans
      Azure Storage requirements
      Testing locally with Azurite
      Azure Functions authorization levels
      Azure Functions support for dependency injection
      Installing Azure Functions Core Tools
   Building an Azure Functions project
      Using Visual Studio 2022
      Using Visual Studio Code
      Using the func CLI
      Reviewing the Azure Functions project
      Implementing a simple function
      Testing a simple function
   Responding to timer and resource triggers
      Implementing a Timer triggered function
      Testing the Timer triggered function
      Implementing a function that works with queues and BLOBs
      Testing the function that works with queues and BLOBs
   Publishing an Azure Functions project to the cloud
      Using Visual Studio 2022 to publish
      Using Visual Studio Code to publish
   Cleaning up Azure Functions resources
   Practicing and exploring
      Exercise 10.1 – Test your knowledge
      Exercise 10.2 – Explore topics
   Summary
Broadcasting Real-Time Communication Using SignalR
   Understanding SignalR
      The history of real-time communication on the web
      AJAX
      WebSocket
      Introducing SignalR
      Azure SignalR Service
      Designing method signatures
   Building a live communication service using SignalR
      Defining some shared models
      Enabling a server-side SignalR hub
   Building a web client using the SignalR JavaScript library
      Adding a chat page to the MVC website
      Testing the chat feature
   Building a .NET console app client
      Creating a .NET client for SignalR
      Testing the .NET console app client
   Streaming data using SignalR
      Defining a hub for streaming
      Creating a .NET console app client for streaming
      Testing the streaming service and client
   Practicing and exploring
      Exercise 11.1 – Test your knowledge
      Exercise 11.2 – Explore topics
   Summary
Combining Data Sources Using GraphQL
   Understanding GraphQL
      GraphQL query document format
         Requesting fields
         Specifying filters and arguments
      Understanding other GraphQL capabilities
      Understanding the ChilliCream GraphQL platform
   Building a service that supports GraphQL
      Defining the GraphQL schema for Hello World
      Writing and executing GraphQL queries
      Naming GraphQL queries aka operations
      Understanding field conventions
   Defining GraphQL queries for EF Core models
      Adding support for EF Core
      Exploring GraphQL queries with Northwind
      Implementing paging support
      Implementing filtering support
      Implementing sorting support
   Building .NET clients for a GraphQL service
      Choosing GraphQL request formats
      Understanding the GraphQL response format
      Using REST Client as a GraphQL client
      Using an ASP.NET Core MVC project as a GraphQL client
      Testing the .NET client
      Creating a console app client using Strawberry Shake
   Implementing GraphQL mutations
      Adding mutations to the GraphQL service
      Exploring the add product mutation
      Implementing updates and deletes as mutations
   Implementing GraphQL subscriptions
      Adding a subscription and topic to the GraphQL service
      Exploring subscribing to a topic
   Practicing and exploring
      Exercise 12.1 – Test your knowledge
      Exercise 12.2 – Explore topics
      Exercise 12.3 – Practice building .NET clients
   Summary
Building Efficient Microservices Using gRPC
   Understanding gRPC
      How gRPC works
      Defining gRPC contracts with .proto files
      gRPC benefits
      gRPC limitations
      Types of gRPC methods
      Microsoft’s gRPC packages
   Building a gRPC service and client
      Building a Hello World gRPC service
      Project file item configuration
      Building a Hello World gRPC client
      Testing a gRPC service and client
   Implementing gRPC for an EF Core model
      Implementing the gRPC service
      Implementing the gRPC client
   Taking gRPC further
      Improving a gRPC service with native AOT publish
      Getting request and response metadata
      Adding a deadline for higher reliability
   Handling dates, times, and decimal numbers
      Defining a custom decimal type and using date/time types
      Implementing the product and employee gRPC services
      Adding product and employee gRPC clients
      Testing decimal, date, and bytes handling
   Implementing interceptors and handling faults
      Adding a client-side interceptor
      Exception and transient fault handling
   Implementing gRPC JSON transcoding
      Enabling gRPC JSON transcoding
      Testing gRPC JSON transcoding
      Comparing with gRPC-Web
   Practicing and exploring
      Exercise 13.1 – Test your knowledge
      Exercise 13.2 – Compare gRPC services with HTTP APIs
      Exercise 13.3 – Explore topics
   Summary
Building Web User Interfaces Using ASP.NET Core
   Setting up an ASP.NET Core MVC website
      Creating an ASP.NET Core MVC website
      Exploring the default ASP.NET Core MVC website
      Understanding visitor registration
      Reviewing an MVC website project structure
      Referencing an EF Core class library and registering a data context
   Defining web user interfaces with Razor views
      Understanding Razor views
      Prototyping with Bootstrap
      Understanding Razor syntax and expressions
      Understanding HTML Helper methods
      Defining a strongly-typed Razor view
   Localizing and globalizing with ASP.NET Core
      Creating resource files
         If you are using Visual Studio 2022
         If you are using Visual Studio Code
      Localizing Razor views with an injected view localizer
      Understanding the Accept-Language header
   Defining web user interfaces with Tag Helpers
      Comparing HTML Helpers and Tag Helpers
      Exploring the Anchor Tag Helper
      Exploring the Cache Tag Helpers
      Exploring the Environment Tag Helper
      Understanding how cache busting with Tag Helpers works
      Exploring Forms-related Tag Helpers
   Output caching
      Output caching endpoints
      Output caching MVC views
   Practicing and exploring
      Exercise 14.1 – Test your knowledge
      Exercise 14.2 – Practice building user interfaces with Boostrap
      Exercise 14.3 – Explore topics
   Summary
Building Web Components Using Blazor
   Understanding Blazor
      Blazor hosting models
      Blazor components
      Blazor routing to page components
      How to pass route parameters
      Setting parameters from a query string
      Route constraints for parameters
      Base component classes
      Blazor layouts
      How to navigate Blazor routes to page components
      CSS and JavaScript isolation
   Building Blazor components
      Reviewing the new Blazor project template
      Using Bootstrap icons
      Referencing an EF Core class library and registering a data context
      Building a static server rendered component for data
      Building a component with server interactivity
      Building a Blazor progress bar component
      Building a Blazor dialog box component
      Building a Blazor alert component
   Building a Blazor data component
      Making the component
      Making the component a routable page component
      Getting entities into a component by building a web service
      Getting entities into a component by calling the web service
   Practicing and exploring
      Exercise 15.1 – Test your knowledge
      Exercise 15.2 – Practice building Blazor components
      Exercise 15.3 – Practice building an IndexedDB interop service
      Exercise 15.4 – Explore topics
      Exercise 15.5 – Explore Blazor WebAssembly topics
      Exercise 15.6 – Explore Progressive Web Apps with Blazor
      Exercise 15.7 – Leveraging Open Source Blazor Component Libraries
   Summary
Building Mobile and Desktop Apps Using .NET MAUI
   Understanding XAML
      Simplifying code using XAML
      .NET MAUI namespaces
      Type converters
      Choosing between .NET MAUI controls
      Markup extensions
   Understanding .NET MAUI
      .NET MAUI and Xamarin support
      Development tools for mobile first, cloud first
      Installing .NET MAUI workloads manually
      .NET MAUI user interface component categories
         Shell control
         ListView control
         Entry and Editor controls
      .NET MAUI handlers
      Writing platform-specific code
   Building mobile and desktop apps using .NET MAUI
      Creating a virtual Android device for local app testing
      Enabling Windows developer mode
      Creating a .NET MAUI project
      Adding shell navigation and more content pages
      Implementing more content pages
   Using shared resources
      Defining resources to share across an app
      Referencing shared resources
      Changing shared resources dynamically
   Using data binding
      Binding to elements
   Practicing and exploring
      Exercise 16.1 – Test your knowledge
      Exercise 16.2 – Explore topics
      Exercise 16.3 – Implementing Model-View-ViewModel for .NET MAUI
      Exercise 16.4 – Integrating .NET MAUI apps with Blazor and native platforms
   Summary
Epilogue
   Cloud-native development using .NET Aspire
   Introducing the Survey Project Challenge
   Third edition coming in December 2025
   Next steps on your C# and .NET learning journey
      Companion books to continue your learning journey
      Other books to take your learning further
   Good luck!
Index