Pro ASP.NET Core 7

Pro ASP.NET Core 7, Tenth Edition
Praises from reviewers of Pro ASP.NET Core 7, Tenth Edition
dedication
contents
preface
about this book
	Who should read this book
	How this book is organized: a roadmap
	About the code
	liveBook discussion forum
about the author
about the cover illustration
1 Putting ASP.NET Core in context
	1.1	Understanding the application frameworks
		1.1.1	Understanding the MVC Framework
		1.1.2	Understanding Razor Pages
		1.1.3	Understanding Blazor
		1.1.4	Understanding the utility frameworks
		1.1.5	Understanding the ASP.NET Core platform
	1.2	Understanding this book
		1.2.1	What software do I need to follow the examples?
		1.2.2	What platform do I need to follow the examples?
		1.2.3	What if I have problems following the examples?
		1.2.4	What if I find an error in the book?
		1.2.5	What does this book cover?
		1.2.6	What doesn’t this book cover?
		1.2.7	How do I contact the author?
		1.2.8	What if I really enjoyed this book?
		1.2.9	What if this book has made me angry and I want to complain?
	Summary
Part 1
	2 Getting started
		2.1	Choosing a code editor
			2.1.1	Installing Visual Studio
			2.1.2	Installing Visual Studio Code
		2.2	Creating an ASP.NET Core project
			2.2.1	Opening the project using Visual Studio
			2.2.2	Opening the project with Visual Studio Code
		2.3	Running the ASP.NET Core application
			2.3.1	Understanding endpoints
			2.3.2	Understanding routes
			2.3.3	Understanding HTML rendering
			2.3.4	Putting the pieces together
		Summary
	3 Your first ASP.NET Core application
		3.1 Setting the scene
		3.2 Creating the project
			3.2.1 Preparing the project
			3.2.2 Adding a data model
			3.2.3 Creating a second action and view
			3.2.4 Linking action methods
			3.2.5 Building the form
			3.2.6 Receiving form data
			3.2.7 Adding the thanks view
			3.2.8 Displaying responses
			3.2.9 Adding validation
			3.2.10 Styling the content
		Summary
	4 Using the development tools
		4.1 Creating ASP.NET Core projects
			4.1.1	Creating a project using the command line
		4.2	Adding code and content to projects
			4.2.1	Understanding item scaffolding
		4.3	Building and running projects
			4.3.1	Using the hot reload feature
		4.4	Managing packages
			4.4.1	Managing NuGet packages
			4.4.2	Managing tool packages
			4.4.3	Managing client-side packages
		4.5	Debugging projects
		Summary
	5 Essential C# features
		5.1	Preparing for this chapter
			5.1.1	Opening the project
			5.1.2	Enabling the MVC Framework
			5.1.3	Creating the application components
			5.1.4	Selecting the HTTP port
			5.1.5	Running the example application
		5.2	Understanding top-level statements
		5.3	Understanding global using statements
			5.3.1	Understanding implicit using statements
		5.4	Understanding null state analysis
			5.4.1	Ensuring fields and properties are assigned values
			5.4.2	Providing a default value for non-nullable types
			5.4.3	Using nullable types
			5.4.4	Checking for null values
			5.4.5	Overriding null state analysis
			5.4.6	Disabling null state analysis warnings
		5.5	Using string interpolation
		5.6	Using object and collection initializers
			5.6.1	Using an index initializer
		5.7	Using target-typed new expressions
		5.8	Pattern Matching
			5.8.1	Pattern matching in switch statements
		5.9	Using extension methods
			5.9.1	Applying extension methods to an interface
			5.9.2	Creating filtering extension methods
		5.10	Using lambda expressions
			5.10.1	Defining functions
			5.10.2	Using lambda expression methods and properties
		5.11	Using type inference and anonymous types
			5.11.1	Using anonymous types
		5.12	Using default implementations in interfaces
		5.13	Using asynchronous methods
			5.13.1	Working with tasks directly
			5.13.2	Applying the async and await keywords
			5.13.3	Using an asynchronous enumerable
		5.14	Getting names
		Summary
	6 Testing ASP.NET Core applications
		6.1	Preparing for this chapter
			6.1.1	Opening the project
			6.1.2	Selecting the HTTP port
			6.1.3	Enabling the MVC Framework
			6.1.4	Creating the application components
			6.1.5	Running the example application
		6.2	Creating a unit test project
		6.3	Writing and running unit tests
			6.3.1	Running tests with the Visual Studio Test Explorer
			6.3.2	Running tests with Visual Studio Code
			6.3.3	Running tests from the command line
			6.3.4	Correcting the unit test
			6.3.5	Isolating components for unit testing
			6.3.6	Using a mocking package
			6.3.7	Creating a mock object
		Summary
	7 SportsStore: A real application
		7.1	Creating the projects
			7.1.1	Creating the unit test project
			7.1.2	Opening the projects
			7.1.3	Configuring the HTTP port
			7.1.4	Creating the application project folders
			7.1.5	Preparing the services and the request pipeline
			7.1.6	Configuring the Razor view engine
			7.1.7	Creating the controller and view
			7.1.8	Starting the data model
			7.1.9	Checking and running the application
		7.2	Adding data to the application
			7.2.1	Installing the Entity Framework Core packages
			7.2.2	Defining the connection string
			7.2.3	Creating the database context class
			7.2.4	Configuring Entity Framework Core
			7.2.5	Creating a repository
			7.2.6	Creating the database migration
			7.2.7	Creating seed data
		7.3	Displaying a list of products
			7.3.1	Preparing the controller
			7.3.2	Updating the view
			7.3.3	Running the application
		7.4	Adding pagination
			7.4.1	Displaying page links
			7.4.2	Improving the URLs
		7.5	Styling the content
			7.5.1	Installing the Bootstrap package
			7.5.2	Applying Bootstrap styles
			7.5.3	Creating a partial view
		Summary
	8 SportsStore: Navigation and cart
		8.1	Adding navigation controls
			8.1.1	Filtering the product list
			8.1.2	Refining the URL scheme
			8.1.3	Building a category navigation menu
			8.1.4	Correcting the page count
		8.2	Building the shopping cart
			8.2.1	Configuring Razor Pages
			8.2.2	Creating a Razor Page
			8.2.3	Creating the Add to Cart buttons
			8.2.4	Enabling sessions
			8.2.5	Implementing the cart feature
		Summary
	9 SportsStore: Completing the cart
		9.1	Refining the cart model with a service
			9.1.1	Creating a storage-aware cart class
			9.1.2	Registering the service
			9.1.3	Simplifying the cart Razor Page
		9.2	Completing the cart functionality
			9.2.1	Removing items from the cart
			9.2.2	Adding the cart summary widget
		9.3	Submitting orders
			9.3.1	Creating the model class
			9.3.2	Adding the checkout process
			9.3.3	Creating the controller and view
			9.3.4	Implementing order processing
			9.3.5	Completing the order controller
			9.3.6	Displaying validation errors
			9.3.7	Displaying a summary page
		Summary
	10 SportsStore: Administration
		10.1	Preparing Blazor Server
			10.1.1	Creating the imports file
			10.1.2	Creating the startup Razor Page
			10.1.3	Creating the routing and layout components
			10.1.4	Creating the Razor Components
			10.1.5	Checking the Blazor setup
		10.2	Managing orders
			10.2.1	Enhancing the model
			10.2.2	Displaying orders to the administrator
		10.3	Adding catalog management
			10.3.1	Expanding the repository
			10.3.2	Applying validation attributes to the data model
			10.3.3	Creating the list component
			10.3.4	Creating the detail component
			10.3.5	Creating the editor component
			10.3.6	Deleting products
		Summary
	11 SportsStore: Security and deployment
		11.1	Creating the Identity database
			11.1.1	Installing the Identity package for Entity Framework Core
			11.1.2	Creating the context class
			11.1.3	Defining the connection string
			11.1.4	Configuring the application
			11.1.5	Creating and applying the database migration
			11.1.6	Defining the seed data
		11.2	Adding a conventional administration feature
		11.3	Applying a basic authorization policy
		11.4	Creating the account controller and views
		11.5	Testing the security policy
		11.6	Preparing ASP.NET Core for deployment
			11.6.1	Configuring error handling
			11.6.2	Creating the production configuration settings
			11.6.3	Creating the Docker image
			11.6.4	Running the containerized application
		Summary
Part 2
	12 Understanding the ASP.NET Core platform
		12.1	Preparing for this chapter
			12.1.1	Running the example application
		12.2	Understanding the ASP.NET Core platform
			12.2.1	Understanding middleware and the request pipeline
			12.2.2	Understanding services
		12.3	Understanding the ASP.NET Core project
			12.3.1	Understanding the entry point
			12.3.2	Understanding the project file
		12.4	Creating custom middleware
			12.4.1	Defining middleware using a class
			12.4.2	Understanding the return pipeline path
			12.4.3	Short-Circuiting the request pipeline
			12.4.4	Creating pipeline branches
			12.4.5	Creating terminal middleware
		12.5	Configuring middleware
			12.5.1	Using the options pattern with class-based middleware
		Summary
	13 Using URL routing
		13.1	Preparing for this chapter
			13.1.1	Understanding URL routing
			13.1.2	Adding the routing middleware and defining an endpoint
			13.1.3	Simplifying the pipeline configuration
			13.1.4	Understanding URL patterns
			13.1.5	Using segment variables in URL patterns
			13.1.6	Generating URLs from routes
		13.2	Managing URL matching
			13.2.1	Matching multiple values from a single URL segment
			13.2.2	Using default values for segment variables
			13.2.3	Using optional segments in a URL Pattern
			13.2.4	Using a catchall segment variable
			13.2.5	Constraining segment matching
			13.2.6	Defining fallback routes
		13.3	Advanced routing features
			13.3.1	Creating custom constraints
			13.3.2	Avoiding ambiguous route exceptions
			13.3.3	Accessing the endpoint in a middleware component
		Summary
	14 Using dependency injection
		14.1	Preparing for this chapter
			14.1.1	Creating a middleware component and an endpoint
			14.1.2	Configuring the request pipeline
		14.2	Understanding service location and tight coupling
			14.2.1	Understanding the service location problem
			14.2.2	Understanding the tightly coupled components problem
		14.3	Using dependency injection
			14.3.1	Using a Service with a Constructor Dependency
			14.3.2	Getting services from the HttpContext object
		14.4	Using Service Lifecycles
			14.4.1	Creating transient services
			14.4.2	Avoiding the transient service reuse pitfall
			14.4.3	Using scoped services
		14.5	Other dependency injection features
			14.5.1	Creating dependency chains
			14.5.2	Accessing services in the Program.cs file
			14.5.3	Using service factory functions
			14.5.4	Creating services with multiple implementations
			14.5.5	Using unbound types in services
		Summary
	15 Using the platform features, part 1
		15.1	Preparing for this chapter
		15.2	Using the configuration service
			15.2.1	Understanding the environment configuration file
			15.2.2	Accessing configuration settings
			15.2.3	Using the configuration data in the Program.cs file
			15.2.4	Using configuration data with the options pattern
			15.2.5	Understanding the launch settings file
			15.2.6	Using the environment service
			15.2.7	Storing user secrets
		15.3	Using the logging service
			15.3.1 Generating logging messages
			15.3.2	Logging messages with attributes
			15.3.3	Configuring minimum logging levels
			15.3.4	Logging HTTP requests and responses
		15.4	Using static content and client-side packages
			15.4.1	Adding the static content middleware
			15.4.2	Using client-side packages
		Summary
	16 Using the platform features, part 2
		16.1	Preparing for this chapter
		16.2	Using cookies
			16.2.1	Enabling cookie consent checking
			16.2.2	Managing cookie consent
		16.3	Using sessions
			16.3.1	Configuring the session service and middleware
			16.3.2	Using session data
		16.4	Working with HTTPS connections
			16.4.1	Enabling HTTPS connections
			16.4.2	Detecting HTTPS requests
			16.4.3	Enforcing HTTPS requests
			16.4.4	Enabling HTTP strict transport security
		16.5	Using rate limits
		16.6	Handling exceptions and errors
			16.6.1	Returning an HTML error response
			16.6.2	Enriching status code responses
		16.7	Filtering requests using the host header
		Summary
	17 Working with data
		17.1	Preparing for this chapter
		17.2	Caching data
			17.2.1	Caching data values
			17.2.2	Using a shared and persistent data cache
		17.3	Caching responses
		17.4	Caching output
			17.4.1	Defining a custom cache policy
		17.5	Using Entity Framework Core
			17.5.1	Installing Entity Framework Core
			17.5.2	Creating the data model
			17.5.3	Configuring the database service
			17.5.4	Creating and applying the database migration
			17.5.5	Seeding the database
			17.5.6	Using data in an endpoint
		Summary
Part 3
	18 Creating the example project
		18.1	Creating the project
		18.2	Adding a data model
			18.2.1	Adding NuGet packages to the project
			18.2.2	Creating the data model
			18.2.3	Preparing the seed data
			18.2.4	Configuring EF Core services and middleware
			18.2.5	Creating and applying the migration
		18.3	Adding the CSS framework
		18.4	Configuring the request pipeline
		18.5	Running the example application
	19 Creating RESTful web services
		19.1	Preparing for this chapter
		19.2	Understanding RESTful web services
			19.2.1	Understanding request URLs and methods
			19.2.2	Understanding JSON
		19.3	Creating a web service using the minimal API
		19.4	Creating a web service using a controller
			19.4.1	Enabling the MVC Framework
			19.4.2	Creating a controller
		19.5	Improving the web service
			19.5.1	Using asynchronous actions
			19.5.2	Preventing over-binding
			19.5.3	Using action results
			19.5.4	Validating data
			19.5.5	Applying the API controller attribute
			19.5.6	Omitting Null properties
			19.5.7	Applying a rate limit
		Summary
	20 Advanced web service features
		20.1	Preparing for this chapter
			20.1.1	Dropping the database
			20.1.2	Running the example application
		20.2	Dealing with related data
			20.2.1	Breaking circular references in related data
		20.3	Supporting the HTTP PATCH method
			20.3.1	Understanding JSON Patch
			20.3.2	Installing and configuring the JSON Patch package
			20.3.3	Defining the action method
		20.4	Understanding content formatting
			20.4.1	Understanding the default content policy
			20.4.2	Understanding content negotiation
			20.4.3	Specifying an action result format
			20.4.4	Requesting a format in the URL
			20.4.5	Restricting the formats received by an action method
			20.4.6	Caching output
		20.5	Documenting and exploring web services
			20.5.1	Resolving action conflicts
			20.5.2	Installing and configuring the Swashbuckle package
			20.5.3	Fine-Tuning the API description
		Summary
	21 Using controllers with views, part I
		21.1	Preparing for this chapter
			21.1.1	Dropping the database
			21.1.2	Running the example application
		21.2	Getting started with views
			21.2.1	Configuring the application
			21.2.2	Creating an HTML controller
			21.2.3	Creating a Razor View
			21.2.4	Selecting a View by name
		21.3	Working with Razor Views
			21.3.1	Setting the view model type
			21.3.2	Understanding the view model type pitfall
		21.4	Understanding the Razor syntax
			21.4.1	Understanding directives
			21.4.2	Understanding content expressions
			21.4.3	Setting element content
			21.4.4	Setting attribute values
			21.4.5	Using conditional expressions
			21.4.6	Enumerating sequences
			21.4.7	Using Razor code blocks
		Summary
	22 Using controllers with views, part II
		22.1	Preparing for this chapter
			22.1.1	Dropping the database
			22.1.2	Running the example application
		22.2	Using the view bag
		22.3	Using temp data
		22.4	Working with layouts
			22.4.1	Configuring layouts using the view bag
			22.4.2	Using a view start file
			22.4.3	Overriding the default layout
			22.4.4	Using layout sections
		22.5	Using partial views
			22.5.1	Enabling partial views
			22.5.2	Creating a partial view
			22.5.3	Applying a partial view
		22.6	Understanding content-encoding
			22.6.1	Understanding HTML encoding
			22.6.2	Understanding JSON encoding
		Summary
	23 Using Razor Pages
		23.1	Preparing for this chapter
			23.1.1	Running the example application
		23.2	Understanding Razor Pages
			23.2.1	Configuring Razor Pages
			23.2.2	Creating a Razor Page
		23.3	Understanding Razor Pages routing
			23.3.1	Specifying a routing pattern in a Razor Page
			23.3.2	Adding routes for a Razor Page
		23.4	Understanding the Page model class
			23.4.1	Using a code-behind class file
			23.4.2	Understanding action results in Razor Pages
			23.4.3	Handling multiple HTTP methods
			23.4.4	Selecting a handler method
		23.5	Understanding the Razor Page view
			23.5.1	Creating a layout for Razor Pages
			23.5.2	Using partial views in Razor Pages
			23.5.3	Creating Razor Pages without page models
		Summary
	24 Using view components
		24.1	Preparing for this chapter
			24.1.1	Dropping the database
			24.1.2	Running the example application
		24.2	Understanding view components
		24.3	Creating and using a view component
			24.3.1	Applying a view component
		24.4	Understanding view component results
			24.4.1	Returning a partial view
			24.4.2	Returning HTML fragments
		24.5	Getting context data
			24.5.1	Providing context from the parent view using arguments
			24.5.2	Creating asynchronous view components
		24.6	Creating view components classes
			24.6.1	Creating a hybrid controller class
		Summary
	25 Using tag helpers
		25.1	Preparing for this chapter
			25.1.1	Dropping the database
			25.1.2	Running the example application
		25.2	Creating a tag helper
			25.2.1	Defining the tag helper class
			25.2.2	Registering tag helpers
			25.2.3	Using a tag helper
			25.2.4	Narrowing the scope of a tag helper
			25.2.5	Widening the scope of a tag helper
		25.3	Advanced tag helper features
			25.3.1	Creating shorthand elements
			25.3.2	Creating elements programmatically
			25.3.3	Prepending and appending content and elements
			25.3.4	Getting view context data
			25.3.5	Working with model expressions
			25.3.6	Coordinating between tag helpers
			25.3.7	Suppressing the output element
		25.4	Using tag helper components
			25.4.1	Creating a tag helper component
			25.4.2	Expanding tag helper component element selection
		Summary
	26 Using the built-in tag helpers
		26.1	Preparing for this chapter
			26.1.1	Adding an image file
			26.1.2	Installing a client-side package
			26.1.3	Dropping the database
			26.1.4	Running the example application
		26.2	Enabling the built-in tag helpers
		26.3	Transforming anchor elements
			26.3.1	Using anchor elements for Razor Pages
		26.4	Using the JavaScript and CSS tag helpers
			26.4.1	Managing JavaScript files
			26.4.2	Managing CSS stylesheets
		26.5	Working with image elements
		26.6	Using the data cache
			26.6.1	Setting cache expiry
		26.7	Using the hosting environment tag helper
		Summary
	27 Using the forms tag helpers
		27.1	Preparing for this chapter
			27.1.1	Dropping the database
			27.1.2	Running the example application
		27.2	Understanding the form handling pattern
			27.2.1	Creating a controller to handle forms
			27.2.2	Creating a Razor Page to handle forms
		27.3	Using tag helpers to improve HTML forms
			27.3.1	Working with form elements
			27.3.2	Transforming form buttons
		27.4	Working with input elements
			27.4.1	Transforming the input element type attribute
			27.4.2	Formatting input element values
			27.4.3	Displaying values from related data in input elements
		27.5	Working with label elements
		27.6	Working with select and option elements
			27.6.1	Populating a select element
		27.7	Working with text areas
		27.8	Using the anti-forgery feature
			27.8.1	Enabling the anti-forgery feature in a controller
			27.8.2	Enabling the anti-forgery feature in a Razor Page
			27.8.3	Using anti-forgery tokens with JavaScript clients
	28 Using model binding
		28.1	Preparing for this chapter
			28.1.1	Dropping the database
			28.1.2	Running the example application
		28.2	Understanding model binding
		28.3	Binding simple data types
			28.3.1	Binding simple data types in Razor Pages
			28.3.2	Understanding default binding values
		28.4	Binding complex types
			28.4.1	Binding to a property
			28.4.2	Binding nested complex types
			28.4.3	Selectively binding properties
		28.5	Binding to arrays and collections
			28.5.1	Binding to arrays
			28.5.2	Binding to simple collections
			28.5.3	Binding to dictionaries
			28.5.4	Binding to collections of complex types
		28.6	Specifying a model binding source
			28.6.1	Selecting a binding source for a property
			28.6.2	Using headers for model binding
			28.6.3	Using request bodies as binding sources
		28.7	Manual model binding
	29 Using model validation
		29.1	Preparing for this chapter
			29.1.1	Dropping the database
			29.1.2	Running the example application
		29.2	Understanding the need for model validation
		29.3	Validating data
			29.3.1	Displaying validation messages
			29.3.2	Understanding the implicit validation checks
			29.3.3	Performing explicit validation
			29.3.4	Configuring the default validation error messages
			29.3.5	Displaying property-level validation messages
			29.3.6	Displaying model-level messages
		29.4	Explicitly validating data in a Razor Page
		29.5	Specifying validation rules using metadata
			29.5.1	Creating a custom property validation attribute
			29.5.2	Creating a custom model validation attribute
		29.6	Performing client-side validation
		29.7	Performing remote validation
			29.7.1	Performing remote validation in Razor Pages
	30 Using filters
		30.1	Preparing for this chapter
			30.1.1	Enabling HTTPS Connections
			30.1.2	Dropping the database
			30.1.3	Running the example application
		30.2	Using filters
		30.3	Understanding filters
		30.4	Creating custom filters
			30.4.1	Understanding authorization filters
			30.4.2	Understanding resource filters
			30.4.3	Understanding action filters
			30.4.4	Understanding page filters
			30.4.5	Understanding result filters
			30.4.6	Understanding exception filters
			30.4.7	Creating an exception filter
		30.5	Managing the filter lifecycle
			30.5.1	Creating filter factories
			30.5.2	Using dependency injection scopes to manage filter lifecycles
		30.6	Creating global filters
		30.7	Understanding and changing filter order
	31 Creating form applications
		31.1	Preparing for this chapter
			31.1.1	Dropping the database
			31.1.2	Running the example application
		31.2	Creating an MVC forms application
			31.2.1	Preparing the view model and the view
			31.2.2	Reading data
			31.2.3	Creating data
			31.2.4	Editing data
			31.2.5	Deleting data
		31.3	Creating a Razor Pages forms application
			31.3.1	Creating common functionality
			31.3.2	Defining pages for the CRUD operations
		31.4	Creating new related data objects
			31.4.1	Providing the related data in the same request
			31.4.2	Breaking out to create new data
Part 4
	32 Creating the example project
		32.1	Creating the project
			32.1.1	Adding NuGet packages to the project
		32.2	Adding a data model
			32.2.1	Preparing the seed data
			32.2.2	Configuring Entity Framework Core
			32.2.3	Creating and applying the migration
		32.3	Adding the Bootstrap CSS framework
		32.4	Configuring the services and middleware
		32.5	Creating a controller and view
		32.6	Creating a Razor Page
		32.7	Running the example application
	33 Using Blazor Server, part 1
		33.1	Preparing for this chapter
		33.2	Understanding Blazor Server
			33.2.1	Understanding the Blazor Server advantages
			33.2.2	Understanding the Blazor Server disadvantages
			33.2.3	Choosing between Blazor Server and Angular/React/Vue.js
		33.3	Getting started with Blazor
			33.3.1	Configuring ASP.NET Core for Blazor Server
			33.3.2	Creating a Razor Component
		33.4	Understanding the basic Razor Component features
			33.4.1	Understanding Blazor events and data bindings
			33.4.2	Working with data bindings
		33.5	Using class files to define components
			33.5.1	Using a code-behind class
			33.5.2	Defining a Razor Component class
	34 Using Blazor Server, part 2
		34.1	Preparing for this chapter
		34.2	Combining components
			34.2.1	Configuring components with attributes
			34.2.2	Creating custom events and bindings
		34.3	Displaying child content in a component
			34.3.1	Creating template components
			34.3.2	Using generic type parameters in template components
			34.3.3	Cascading parameters
		34.4	Handling errors
			34.4.1	Handling connection errors
			34.4.2	Handling uncaught application errors
			34.4.3	Using error boundaries
	35 Advanced Blazor features
		35.1	Preparing for this chapter
		35.2	Using component routing
			35.2.1	Preparing the Razor Page
			35.2.2	Adding routes to components
			35.2.3	Navigating between routed components
			35.2.4	Receiving routing data
			35.2.5	Defining common content using layouts
		35.3	Understanding the component lifecycle methods
			35.3.1	Using the lifecycle methods for asynchronous tasks
		35.4	Managing component interaction
			35.4.1	Using references to child components
			35.4.2	Interacting with components from other code
			35.4.3	Interacting with components using JavaScript
	36 Blazor forms and data
		36.1	Preparing for this chapter
			36.1.1	Dropping the database and running the application
		36.2	Using the Blazor form components
			36.2.1	Creating custom form components
			36.2.2	Validating form data
			36.2.3	Handling form events
		36.3	Using Entity Framework Core with Blazor
			36.3.1	Understanding the EF Core context scope issue
			36.3.2	Understanding the repeated query issue
		36.4	Performing CRUD operations
			36.4.1	Creating the list component
			36.4.2	Creating the details component
			36.4.3	Creating the editor component
		36.5	Extending the Blazor form features
			36.5.1	Creating a custom validation constraint
			36.5.2	Creating a valid-only submit button component
	37 Using Blazor WebAssembly
		37.1	Preparing for this chapter
			37.1.1	Dropping the database and running the application
		37.2	Setting Up Blazor WebAssembly
			37.2.1	Creating the shared project
			37.2.2	Creating the Blazor WebAssembly project
			37.2.3	Preparing the ASP.NET Core project
			37.2.4	Adding the solution references
			37.2.5	Opening the projects
			37.2.6	Completing the Blazor WebAssembly configuration
			37.2.7	Testing the placeholder components
		37.3	Creating a Blazor WebAssembly component
			37.3.1	Importing the data model namespace
			37.3.2	Creating a component
			37.3.3	Creating a layout
			37.3.4	Defining CSS styles
		37.4	Completing the Blazor WebAssembly Form application
			37.4.1	Creating the details component
			37.4.2	Creating the editor component
	38 Using ASP.NET Core Identity
		38.1	Preparing for this chapter
		38.2	Preparing the project for ASP.NET Core Identity
			38.2.1	Preparing the ASP.NET Core Identity database
			38.2.2	Configuring the application
			38.2.3	Creating and applying the Identity database migration
		38.3	Creating user management tools
			38.3.1	Preparing for user management tools
			38.3.2	Enumerating user accounts
			38.3.3	Creating users
			38.3.4	Editing users
			38.3.5	Deleting users
		38.4	Creating role management tools
			38.4.1	Preparing for role management tools
			38.4.2	Enumerating and deleting roles
			38.4.3	Creating roles
			38.4.4	Assigning role membership
	39 Applying ASP.NET Core Identity
		39.1	Preparing for this chapter
		39.2	Authenticating users
			39.2.1	Creating the login feature
			39.2.2	Inspecting the ASP.NET Core Identity cookie
			39.2.3	Creating a Sign-Out page
			39.2.4	Testing the authentication feature
			39.2.5	Enabling the Identity authentication middleware
		39.3	Authorizing access to endpoints
			39.3.1	Applying the authorization attribute
			39.3.2	Enabling the authorization middleware
			39.3.3	Creating the access denied endpoint
			39.3.4	Creating the seed data
			39.3.5	Testing the authentication sequence
		39.4	Authorizing access to Blazor applications
			39.4.1	Performing authorization in Blazor components
			39.4.2	Displaying content to authorized users
		39.5	Authenticating and authorizing web services
			39.5.1	Building a simple JavaScript client
			39.5.2	Restricting access to the web service
			39.5.3	Using cookie authentication
			39.5.4	Using bearer token authentication
			39.5.5	Creating tokens
			39.5.6	Authenticating with tokens
			39.5.7	Restricting access with tokens
			39.5.8	Using tokens to request data
index