Apps and Services with .NET 7. Build practical projects with Blazor, .NET MAUI, gRPC, GraphQL, and other enterprise technologies

Cover
Quick Chapter Reference
Table of Contents
Preface
Chapter 1: Introducing Apps and Services with .NET
Introducing this book and its contents
A companion book to continue your learning journey
What you will learn in this book
My learning philosophy
Fixing my mistakes
Project naming and port numbering conventions
Treating warnings as errors
App and service technologies
Building websites and apps using ASP.NET Core
Building web and other services
Windows Communication Foundation (WCF)
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 Uno platform
Understanding Avalonia
Setting up your development environment
Choosing the appropriate tool and application type for learning
Using Visual Studio Code for cross-platform development
Using GitHub Codespaces for development in the cloud
Using Visual Studio for Mac for general development
Using Visual Studio for Windows for general development
What I used
Deploying cross-platform
Downloading and installing Visual Studio 2022 for Windows
Visual Studio 2022 for Windows keyboard shortcuts
Downloading and installing Visual Studio Code
Installing other extensions
Understanding Visual Studio Code versions
Visual Studio Code keyboard shortcuts
Finding the solution code on GitHub
Consuming Azure resources
Using an analyzer to write better code
Suppressing warnings
Fixing the code
What’s new in C# and .NET?
Understanding .NET support
Understanding .NET Runtime and .NET SDK versions
What’s new in C# 8 and .NET Core 3?
Default interface methods
Switch expressions
Using declarations
Nullable reference types
Indices and ranges
What’s new in C# 9 and .NET 5?
Record types and init-only setters
Top-level statements
Target-typed new
What’s new in C# 10 and .NET 6?
Top-level statements and implicitly imported namespaces by default
Checking for null in method parameters
What’s new in C# 11 and .NET 7?
Raw string literals
Requiring properties to be set during instantiation
Generic math support
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 Microsoft documentation
Getting help for the dotnet tool
Searching for answers using Google
Subscribing to the official .NET blog
Watching Scott Hanselman’s videos
Practicing and exploring
Exercise 1.1 – Test your knowledge
Exercise 1.2 – Explore topics
Summary
Chapter 2: 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
Installing SQL Server Developer Edition for Windows
Visual Studio Code extension for working with SQL Server
Creating the Northwind sample database on Windows
Setting up Azure SQL Database
Installing Azure SQL Edge in Docker
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
Working with ADO.NET asynchronously
Executing stored procedures using ADO.NET
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
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
Cleaning up data resources
Removing Azure resources
Removing Docker resources
Practicing and exploring
Exercise 2.1 – Test your knowledge
Exercise 2.2 – Practice benchmarking ADO.NET against EF Core
Exercise 2.3 – Explore topics
Exercise 2.4 – Explore Dapper
Summary
Chapter 3: 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 Core (SQL) API
Performing CRUD operations with Cosmos SQL API
Understanding SQL queries
Understanding server-side programming
Manipulating graph data with Gremlin API
Cleaning up Azure resources
Practicing and exploring
Exercise 3.1 – Test your knowledge
Exercise 3.2 – Practice data modeling and partitioning
Exercise 3.3 – Explore topics
Exercise 3.4 – Explore NoSQL databases
Exercise 3.5 – Download cheat sheets
Exercise 3.6 – Read a Gremlin guide
Summary
Chapter 4: Benchmarking Performance, Multitasking, and Concurrency
Understanding processes, threads, and tasks
Monitoring performance and resource usage
Evaluating the efficiency of types
Monitoring performance and memory using diagnostics
Useful members of the Stopwatch and Process types
Implementing a Recorder class
Measuring the efficiency of processing strings
Monitoring performance and memory using Benchmark.NET
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 4.1 – Test your knowledge
Exercise 4.2 – Explore topics
Exercise 4.3 – Read more about parallel programming
Summary
Chapter 5: Implementing Popular Third-Party Libraries
Which third-party libraries are most popular?
What is covered in my books
What could be covered in my books
Working with images
Generating grayscale thumbnails
ImageSharp packages for drawing and the web
Logging with Serilog
Structured event data
Serilog sinks
Logging to the console and a rolling file with Serilog
Mapping between objects
Testing 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
Integrating with ASP.NET Core
Generating PDFs
Creating class libraries to generate PDF documents
Creating a console app to generate PDF documents
Practicing and exploring
Exercise 5.1 – Test your knowledge
Exercise 5.2 – Explore topics
Summary
Chapter 6: Observing and Modifying Code Execution Dynamically
Working with reflection and attributes
Versioning of assemblies
Reading assembly metadata
Creating custom attributes
Understanding compiler-generated types and members
Making a type or member obsolete
Dynamically loading assemblies and executing methods
Doing more with reflection
Working with expression trees
Understanding components of expression trees
Executing the simplest expression tree
Creating source generators
Implementing the simplest source generator
Doing more with source generators
Practicing and exploring
Exercise 6.1 – Test your knowledge
Exercise 6.2 – Explore topics
Summary
Chapter 7: 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
Localizing the DayOfWeek enum
Working with only a date or a time
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
Practicing and exploring
Exercise 7.1 – Test your knowledge
Exercise 7.2 – Explore topics
Exercise 7.3 – Learn from expert Jon Skeet
Summary
Chapter 8: Protecting Your Data and Applications
Understanding the vocabulary of protection
Keys and key sizes
IVs and block sizes
Salts
Generating keys and IVs
Encrypting and decrypting data
Encrypting symmetrically with AES
Hashing data
Hashing with the commonly used SHA256
Signing data
Signing with SHA256 and RSA
Generating random numbers
Generating random numbers for games and similar apps
Generating random numbers for cryptography
Authenticating and authorizing users
Authentication and authorization mechanisms
Identifying a user
User membership
Implementing authentication and authorization
Protecting application functionality
Real-world authentication and authorization
Practicing and exploring
Exercise 8.1 – Test your knowledge
Exercise 8.2 – Practice protecting data with encryption and hashing
Exercise 8.3 – Practice protecting data with decryption
Exercise 8.4 – Explore topics
Exercise 8.5 – Review Microsoft encryption recommendations
Summary
Chapter 9: Building and Securing Web Services Using Minimal APIs
Building web services using ASP.NET Core Minimal APIs
Understanding Minimal APIs 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 Visual Studio Code extensions
Excluding paths from OpenAPI documentation
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
Understanding identity services
JWT bearer authorization
Authenticating service clients using JWT bearer authentication
Practicing and exploring
Exercise 9.1 – Test your knowledge
Exercise 9.2 – Review Microsoft HTTP API design policy
Exercise 9.3 – Explore topics
Summary
Chapter 10: Exposing Data via the Web Using OData
Understanding OData
Understanding the OData standard
Understanding OData queries
Building a web service that supports OData
Defining OData models for the EF Core models
Testing the OData models
Creating and testing OData controllers
Testing OData services using Visual Studio Code extensions
Querying OData services using REST Client
Understanding OData standard query options
Understanding OData operators
Understanding OData functions
Exploring OData queries
Using logs to review the efficiency of OData requests
Versioning OData controllers
Enabling entity inserts, updates, and deletes
Building clients for OData services
Calling services in the Northwind MVC website
Revisiting the introductory query
Practicing and exploring
Exercise 10.1 – Test your knowledge
Exercise 10.2 – Explore topics
Summary
Chapter 11: 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
Understanding field conventions
Defining GraphQL queries for EF Core models
Adding support for EF Core
Exploring GraphQL queries with Northwind
Building a .NET client for a GraphQL service
Understanding GraphQL responses
Using REST Client as a GraphQL client
Using an ASP.NET Core MVC project as a GraphQL client
Testing the .NET client
Understanding Strawberry Shake
Creating a console app client
Implementing GraphQL mutations
Practicing and exploring
Exercise 11.1 – Test your knowledge
Exercise 11.2 – Explore topics
Exercise 11.3 – Practice building .NET clients
Summary
Chapter 12: 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
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
Getting request and response metadata
Adding a deadline for higher reliability
Implementing gRPC JSON transcoding
Enabling gRPC JSON transcoding
Testing gRPC JSON transcoding
Comparing with gRPC-Web
Practicing and exploring
Exercise 12.1 – Test your knowledge
Exercise 12.2 – Explore topics
Summary
Chapter 13: 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 13.1 – Test your knowledge
Exercise 13.2 – Explore topics
Summary
Chapter 14: Building Serverless Nanoservices Using Azure Functions
Understanding Azure Functions
Azure Functions triggers and bindings
NCRONTAB expressions
Azure Functions versions and languages
Azure Functions hosting 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 14.1 – Test your knowledge
Exercise 14.2 – Explore topics
Summary
Chapter 15: 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
Breakpoints and containers
Rows and columns
Color themes
Tables
Buttons and links
Badges
Alerts
Good practice for 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
Using Visual Studio 2022
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
Practicing and exploring
Exercise 15.1 – Test your knowledge
Exercise 15.2 – Practice building user interfaces with Bootstrap
Exercise 15.3 – Explore topics
Summary
Chapter 16: Building Web Components Using Blazor WebAssembly
Understanding Blazor
Blazor hosting models
Deployment choices for Blazor WebAssembly apps
The browser compatibility analyzer for Blazor WebAssembly
CSS and JavaScript isolation
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
How to navigate Blazor routes to page components
Building Blazor components
Building and testing a Blazor progress bar component
Building and testing a Blazor dialog box component
Building and testing a Blazor alert component
Building a Blazor data 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
Implementing caching using local storage
Interop with JavaScript modules
Building a local storage service
Building Progressive Web Apps
Implementing offline support for PWAs
Practicing and exploring
Exercise 16.1 – Test your knowledge
Exercise 16.2 – Practice building Blazor components
Exercise 16.3 – Practice building an IndexedDB interop service
Exercise 16.4 – Explore topics
Summary
Chapter 17: Leveraging Open-Source Blazor Component Libraries
Understanding open-source Blazor component libraries
Exploring Radzen Blazor components
Enabling the Radzen dialog, notification, context menu, and tooltip components
Using the Radzen tooltip and context menu components
Using the Radzen notification and dialog components
Building a web service for Northwind entities
Using the Radzen tabs, image, and icon components
Using the Radzen HTML editor component
Using the Radzen chart component
Using the Radzen form components
Testing the employees page component
Practicing and exploring
Exercise 17.1 – Test your knowledge
Exercise 17.2 – Practice by exploring MudBlazor
Exercise 17.3 – Explore topics
Summary
Chapter 18: 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
Development tools for mobile first, cloud first
Installing .NET MAUI workloads manually
Using Windows to create iOS and macOS apps
.NET MAUI user interface components
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 solution
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
Understanding MVVM
INotifyPropertyChanged interface
ObservableCollection class
Creating a view model with two-way data binding
Creating views for the customers list and customer details
Testing the .NET MAUI app
Consuming a web service from a mobile app
Creating a Minimal API web service for customers
Configuring the web service to allow unsecure requests
Connecting to local web services while testing
Configuring the iOS app to allow unsecure connections
Configuring the Android app to allow unsecure connections
Getting customers from the web service
Practicing and exploring
Exercise 18.1 – Test your knowledge
Exercise 18.2 – Explore topics
Summary
Chapter 19: Integrating .NET MAUI Apps with Blazor and Native Platforms
Building .NET MAUI Blazor Hybrid apps
Creating a .NET MAUI Blazor project
Adding a shell and .NET MAUI pages
Creating a minimal API web service for categories
Configuring the .NET MAUI app to allow unsecure connections
Implementing the Model-View-ViewModel pattern
Getting categories from the web service
Integrating with native platforms
Working with the system clipboard
Picking files from the local filesystem
Enabling media and file picking on Windows
Enabling media and file picking on Android
Enabling media and file picking on iOS
Integrating with the media and file picker
Creating new windows
Getting device information
Enabling device information on Android
Adding device information to the app
Integrating with desktop menu bars
Popping up a toast notification
Using third-party control libraries
Practicing and exploring
Exercise 19.1 – Test your knowledge
Exercise 19.2 – Explore the code samples
Exercise 19.3 – Explore topics
Summary
Chapter 20: Introducing the Survey Project Challenge
What have you learned in this book?
Technologies covered in this book
Why a survey project?
What is the best way to learn?
Attributes of a good learning project
Alternative project ideas
Features of survey and polling tools
Question types
Polling and quizzes
Analyzing the responses
What are the product requirements?
Minimal requirements overview
Minimal website requirements
Minimal question item types
Minimal survey design requirements
Minimal data storage requirements
Minimal analysis app requirements
Ideas for extended requirements
Extended website requirements
Extended question item types
Extended survey design requirements
Extended data storage requirements
Extended analysis app requirements
Promote your abilities
Summary
Chapter 21: Epilogue
Second edition coming November 2023
Next steps on your C# and .NET learning journey
Good luck!
Index