Pro ASP.NET Core 7, Tenth Edition (Final Release)

Praises from reviewers of Pro ASP.NET Core 7, Tenth Edition
Pro ASP.NET Core 7
Copyright
dedication
contents
front matter
   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.3 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
      26.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
   Summary
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
   Summary
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.4 Displaying property-level validation messages
      29.3.5 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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
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
   Summary
index