Pro ASP.NET Core 3: Develop Cloud-Ready Web Applications Using MVC, Blazor, and Razor Pages

Table of Contents
About the Author
About the Technical Reviewer
Part I: Introducing ASP.NET Core
	Chapter 1: Putting ASP.NET Core in Context
		Understanding ASP.NET Core
			Understanding the Application Frameworks
				Understanding the MVC Framework
				Understanding Razor Pages
				Understanding Blazor
			Understanding the Utility Frameworks
			Understanding the ASP.NET Core Platform
		Understanding This Book
			What Software Do I Need to Follow the Examples?
			What Platform Do I Need to Follow the Examples?
			What If I Have Problems Following the Examples?
			What If I Find an Error in the Book?
			What Does This Book Cover?
				Part 1: Introducing ASP.NET Core
				Part 2: The ASP.NET Core Platform
				Part 3: ASP.NET Core Applications
				Part 4: Advanced ASP.NET Core Features
			What Doesn’t This Book Cover?
			How Do I Contact the Author?
			What If I Really Enjoyed This Book?
			What If This Book Has Made Me Angry and I Want to Complain?
		Summary
	Chapter 2: Getting Started
		Choosing a Code Editor
			Installing Visual Studio
				Installing the .NET Core SDK
			Installing Visual Studio Code
				Installing the .NET Core SDK
				Installing SQL Server LocalDB
		Creating an ASP.NET Core Project
			Opening the Project Using Visual Studio
				Choosing a Browser
			Opening the Project with Visual Studio Code
		Running the ASP.NET Core Application
			Understanding Endpoints
			Understanding Routes
			Understanding HTML Rendering
				Creating and Rendering a View
				Adding Dynamic Output
			Putting the Pieces Together
		Summary
	Chapter 3: Your First ASP.NET Core Application
		Setting the Scene
		Creating the Project
			Adding a Data Model
			Creating a Second Action and View
			Linking Action Methods
			Building the Form
			Receiving Form Data
				Understanding Model Binding
				Storing Responses
			Adding the Thanks View
			Displaying the Responses
			Adding Validation
				Highlighting Invalid Fields
			Styling the Content
				Styling the Welcome View
				Styling the Form View
				Styling the Thanks View
				Styling the List View
		Summary
	Chapter 4: Using the Development Tools
		Creating ASP.NET Core Projects
			Creating a Project Using the Command Line
				Opening the Project
			Creating a Project Using Visual Studio
		Adding Code and Content to Projects
			Understanding Item Scaffolding
		Building and Running Projects
			Building and Running Projects Using the Command Line
			Building and Running Projects Using Visual Studio Code
			Building and Running Projects Using Visual Studio
		Managing Packages
			Managing NuGet Packages
			Managing Tool Packages
			Managing Client-Side Packages
			Managing Packages Using Visual Studio
				Managing Client-Side Packages Using Visual Studio
		Debugging Projects
		Summary
	Chapter 5: Essential C# Features
		Preparing for This Chapter
			Opening the Project
			Enabling the MVC Framework
			Creating the Application Components
				Creating the Data Model
				Creating the Controller and View
			Selecting the HTTP Port
			Running the Example Application
		Using the Null Conditional Operator
			Chaining the Null Conditional Operator
			Combining the Conditional and Coalescing Operators
		Using Automatically Implemented Properties
			Using Auto-implemented Property Initializers
			Creating Read-Only Automatically Implemented Properties
		Using String Interpolation
		Using Object and Collection Initializers
			Using an Index Initializer
		Pattern Matching
			Pattern Matching in switch Statements
		Using Extension Methods
			Applying Extension Methods to an Interface
			Creating Filtering Extension Methods
		Using Lambda Expressions
			Defining Functions
			Using Lambda Expression Methods and Properties
		Using Type Inference and Anonymous Types
			Using Anonymous Types
		Using Default Implementations in Interfaces
		Using Asynchronous Methods
			Working with Tasks Directly
			Applying the async and await Keywords
			Using an Asynchronous Enumerable
		Getting Names
		Summary
	Chapter 6: Testing ASP.NET Core Applications
		Preparing for This Chapter
			Opening the Project
			Selecting the HTTP Port
			Enabling the MVC Framework
			Creating the Application Components
				Creating the Data Model
				Creating the Controller and View
			Running the Example Application
		Creating a Unit Test Project
			Removing the Default Test Class
		Writing and Running Unit Tests
			Running Tests with the Visual Studio Test Explorer
			Running Tests with Visual Studio Code
			Running Tests from the Command Line
			Correcting the Unit Test
			Isolating Components for Unit Testing
				Isolating a Component
			Using a Mocking Package
			Creating a Mock Object
		Summary
	Chapter 7: SportsStore: A Real Application
		Creating the Projects
			Creating the Unit Test Project
			Creating the Application Project Folders
			Opening the Projects
			Preparing the Application Services and the Request Pipeline
			Configuring the Razor View Engine
			Creating the Controller and View
			Starting the Data Model
			Checking and Running the Application
		Adding Data to the Application
			Installing the Entity Framework Core Packages
			Defining the Connection String
			Creating the Database Context Class
			Configuring Entity Framework Core
			Creating a Repository
			Creating the Database Migration
			Creating Seed Data
		Displaying a List of Products
			Preparing the Controller
			Updating the View
			Running the Application
		Adding Pagination
			Displaying Page Links
				Adding the View Model
				Adding the Tag Helper Class
				Adding the View Model Data
				Displaying the Page Links
			Improving the URLs
		Styling the Content
			Installing the Bootstrap Package
			Applying Bootstrap Styles
			Creating a Partial View
		Summary
	Chapter 8: SportsStore: Navigation and Cart
		Adding Navigation Controls
			Filtering the Product List
			Refining the URL Scheme
			Building a Category Navigation Menu
				Creating the Navigation View Component
				Generating Category Lists
				Creating the View
				Highlighting the Current Category
			Correcting the Page Count
		Building the Shopping Cart
			Configuring Razor Pages
			Creating a Razor Page
			Creating the Add To Cart Buttons
			Enabling Sessions
			Implementing the Cart Feature
				Defining Session State Extension Methods
				Completing the Razor Page
		Summary
	Chapter 9: SportsStore: Completing the Cart
		Refining the Cart Model with a Service
			Creating a Storage-Aware Cart Class
			Registering the Service
			Simplifying the Cart Razor Page
		Completing the Cart Functionality
			Removing Items from the Cart
			Adding the Cart Summary Widget
				Adding the Font Awesome Package
				Creating the View Component Class and View
		Submitting Orders
			Creating the Model Class
			Adding the Checkout Process
			Creating the Controller and View
			Implementing Order Processing
				Extending the Database
				Creating the Order Repository
			Completing the Order Controller
			Displaying Validation Errors
			Displaying a Summary Page
		Summary
	Chapter 10: SportsStore: Administration
		Preparing Blazor Server
			Creating the Imports File
			Creating the Startup Razor Page
			Creating the Routing and Layout Components
			Creating the Razor Components
			Checking the Blazor Setup
		Managing Orders
			Enhancing the Model
			Displaying Orders to the Administrator
		Adding Catalog Management
			Expanding the Repository
			Applying Validation Attributes to the Data Model
			Creating the List Component
			Creating the Detail Component
			Creating the Editor Component
			Deleting Products
		Summary
	Chapter 11: SportsStore: Security and Deployment
		Securing the Administration Features
			Creating the Identity Database
				Installing the Identity Package for Entity Framework Core
				Creating the Context Class
				Defining the Connection String
				Configuring the Application
				Creating and Applying the Database Migration
				Defining the Seed Data
			Adding a Conventional Administration Feature
			Applying a Basic Authorization Policy
			Creating the Account Controller and Views
			Testing the Security Policy
		Preparing ASP.NET Core for Deployment
			Configuring Error Handling
			Creating the Production Configuration Settings
			Creating the Docker Image
				Installing Docker Desktop
				Creating the Docker Configuration Files
				Publishing and Imaging the Application
			Running the Containerized Application
		Summary
Part II: The ASP.NET Core Platform
	Chapter 12: Understanding the ASP.NET Core Platform
		Preparing for This Chapter
			Running the Example Application
		Understanding the ASP.NET Core Platform
			Understanding Middleware and the Request Pipeline
			Understanding Services
		Understanding the ASP.NET Core Project
			Understanding the Entry Point
			Understanding the Startup Class
			Understanding the Project File
		Creating Custom Middleware
			Defining Middleware Using a Class
			Understanding the Return Pipeline Path
			Short-Circuiting the Request Pipeline
			Creating Pipeline Branches
			Creating Terminal Middleware
		Configuring Middleware
			Using the Options Pattern with Class-Based Middleware
		Summary
	Chapter 13: Using URL Routing
		Preparing for This Chapter
			Understanding URL Routing
			Adding the Routing Middleware and Defining an Endpoint
			Understanding URL Patterns
			Using Segment Variables in URL Patterns
				Refactoring Middleware into an Endpoint
			Generating URLs from Routes
		Managing URL Matching
			Matching Multiple Values from a Single URL Segment
			Using Default Values for Segment Variables
			Using Optional Segments in a URL Pattern
			Using a catchall Segment Variable
			Constraining Segment Matching
				Constraining Matching to a Specific Set of Values
			Defining Fallback Routes
		Advanced Routing Features
			Creating Custom Constraints
			Avoiding Ambiguous Route Exceptions
			Accessing the Endpoint in a Middleware Component
		Summary
	Chapter 14: Using Dependency Injection
		Preparing for This Chapter
			Creating a Middleware Component and an Endpoint
			Configuring the Request Pipeline
		Understanding Service Location and Tight Coupling
			Understanding the Service Location Problem
			Understanding the Tightly Coupled Components Problem
		Using Dependency Injection
			Using a Service in a Middleware Class
			Using a Service in an Endpoint
				Getting Services from the HttpContext Object
				Using an Adapter Function
				Using the Activation Utility Class
		Using Service Lifecycles
			Creating Transient Services
			Avoiding the Transient Service Reuse Pitfall
			Using Scoped Services
				Avoiding the Scoped Service Validation Pitfall
				Accessing Scoped Services Through the Context Object
					Creating New Handlers for Each Request
					Using Scoped Services in Lambda Expressions
		Other Dependency Injection Features
			Creating Dependency Chains
			Accessing Services in the ConfigureServices Method
			Using Service Factory Functions
			Creating Services with Multiple Implementations
			Using Unbound Types in Services
		Summary
	Chapter 15: Using the Platform Features, Part 1
		Preparing for This Chapter
		Using the Configuration Service
			Understanding the Environment-Specific Configuration File
			Accessing Configuration Settings
			Using the Configuration Data in Services
				Using Configuration Data with the Options Pattern
			Understanding the Launch Settings File
			Determining the Environment in the Startup Class
			Storing User Secrets
				Storing User Secrets
				Reading User Secrets
		Using the Logging Service
			Generating Logging Messages
			Configuring Minimum Logging Levels
		Using Static Content and Client-Side Packages
			Adding the Static Content Middleware
				Changing the Default Options for the Static Content Middleware
			Using Client-Side Packages
				Preparing the Project for Client-Side Packages
				Installing Client-Side Packages
				Using a Client-Side Package
		Summary
	Chapter 16: Using the Platform Features, Part 2
		Preparing for This Chapter
		Using Cookies
			Enabling Cookie Consent Checking
			Managing Cookie Consent
		Using Sessions
			Configuring the Session Service and Middleware
			Using Session Data
		Working with HTTPS Connections
			Enabling HTTP Connections
			Detecting HTTPS Requests
			Enforcing HTTPS Requests
			Enabling HTTP Strict Transport Security
		Handling Exceptions and Errors
			Returning an HTML Error Response
			Enriching Status Code Responses
		Filtering Requests Using the Host Header
		Summary
	Chapter 17: Working with Data
		Preparing for This Chapter
		Caching Data
			Caching Data Values
			Using a Shared and Persistent Data Cache
				Creating the Persistent Cache Service
		Caching Responses
		Using Entity Framework Core
			Installing Entity Framework Core
			Creating the Data Model
			Configuring the Database Service
			Creating and Applying the Database Migration
			Seeding the Database
			Using Data in an Endpoint
				Enabling Sensitive Data Logging
		Summary
Part III: ASP.NET Core Applications
	Chapter 18: Creating the Example Project
		Creating the Project
		Adding a Data Model
			Adding NuGet Packages to the Project
			Creating the Data Model
			Preparing the Seed Data
			Configuring Entity Framework Core Services and Middleware
			Creating and Applying the Migration
		Adding the CSS Framework
		Configuring the Request Pipeline
		Running the Example Application
		Summary
	Chapter 19: Creating RESTful Web Services
		Preparing for This Chapter
		Understanding RESTful Web Services
			Understanding Request URLs and Methods
			Understanding JSON
		Creating a Web Service Using a Custom Endpoint
		Creating a Web Service Using a Controller
			Enabling the MVC Framework
			Creating a Controller
				Understanding the Base Class
				Understanding the Controller Attributes
				Understanding Action Method Results
				Using Dependency Injection in Controllers
				Using Model Binding to Access Route Data
				Model Binding from the Request Body
				Adding Additional Actions
		Improving the Web Service
			Using Asynchronous Actions
			Preventing Over-Binding
			Using Action Results
				Performing Redirections
				Redirecting to an Action Method
			Validating Data
			Applying the API Controller Attribute
			Omitting Null Properties
				Projecting Selected Properties
				Configuring the JSON Serializer
		Summary
	Chapter 20: Advanced Web Service Features
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Dealing with Related Data
			Breaking Circular References in Related Data
		Supporting the HTTP PATCH Method
			Understanding JSON Patch
			Installing and Configuring the JSON Patch Package
			Defining the Action Method
		Understanding Content Formatting
			Understanding the Default Content Policy
			Understanding Content Negotiation
				Enabling XML Formatting
				Fully Respecting Accept Headers
			Specifying an Action Result Format
			Requesting a Format in the URL
			Restricting the Formats Received by an Action Method
		Documenting and Exploring Web Services
			Resolving Action Conflicts
			Installing and Configuring the Swashbuckle Package
			Fine-Tuning the API Description
				Running the API Analyzer
				Declaring the Action Method Result Type
		Summary
	Chapter 21: Using Controllers with Views, Part I
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Getting Started with Views
			Configuring the Application
			Creating an HTML Controller
				Understanding Convention Routing
				Understanding the Razor View Convention
			Creating a Razor View
				Modifying a Razor View
			Selecting a View by Name
				Using Shared Views
		Working with Razor Views
			Setting the View Model Type
				Using a View Imports File
		Understanding the Razor Syntax
			Understanding Directives
			Understanding Content Expressions
			Setting Element Content
			Setting Attribute Values
			Using Conditional Expressions
			Enumerating Sequences
			Using Razor Code Blocks
		Summary
	Chapter 22: Using Controllers with Views, Part II
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Using the View Bag
		Using Temp Data
		Working with Layouts
			Configuring Layouts Using the View Bag
			Using a View Start File
			Overriding the Default Layout
			Using Layout Sections
				Using Optional Layout Sections
				Testing for Layout Sections
		Using Partial Views
			Enabling Partial Views
			Creating a Partial View
			Applying a Partial View
				Selecting the Partial View Model Using an Expression
		Understanding Content-Encoding
			Understanding HTML Encoding
			Understanding JSON Encoding
		Summary
	Chapter 23: Using Razor Pages
		Preparing for This Chapter
			Running the Example Application
		Understanding Razor Pages
			Configuring Razor Pages
			Creating a Razor Page
				Understanding the URL Routing Convention
				Understanding the Page Model
				Understanding the Page View
				Understanding the Generated C# Class
		Understanding Razor Pages Routing
			Specifying a Routing Pattern in a Razor Page
			Adding Routes for a Razor Page
		Understanding the Page Model Class
			Using a Code-Behind Class File
				Adding a View Imports File
			Understanding Action Results in Razor Pages
				Using an Action Result
			Handling Multiple HTTP Methods
			Selecting a Handler Method
		Understanding the Razor Page View
			Creating a Layout for Razor Pages
			Using Partial Views in Razor Pages
			Creating Razor Pages Without Page Models
		Summary
	Chapter 24: Using View Components
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Understanding View Components
		Creating and Using a View Component
			Applying a View Component
				Applying View Components Using a Tag Helper
				Applying View Components in Razor Pages
		Understanding View Component Results
			Returning a Partial View
			Returning HTML Fragments
		Getting Context Data
			Providing Context from the Parent View Using Arguments
			Creating Asynchronous View Components
		Creating View Components Classes
			Creating a Hybrid Controller Class
		Summary
	Chapter 25: Using Tag Helpers
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Creating a Tag Helper
			Defining the Tag Helper Class
				Receiving Context Data
				Producing Output
			Registering Tag Helpers
			Using a Tag Helper
			Narrowing the Scope of a Tag Helper
			Widening the Scope of a Tag Helper
		Advanced Tag Helper Features
			Creating Shorthand Elements
			Creating Elements Programmatically
			Prepending and Appending Content and Elements
				Inserting Content Around the Output Element
				Inserting Content Inside the Output Element
			Getting View Context Data
			Working with Model Expressions
				Working with the Page Model
			Coordinating Between Tag Helpers
			Suppressing the Output Element
		Using Tag Helper Components
			Creating a Tag Helper Component
			Expanding Tag Helper Component Element Selection
		Summary
	Chapter 26: Using the Built-in Tag Helpers
		Preparing for This Chapter
			Adding an Image File
			Installing a Client-Side Package
			Dropping the Database
			Running the Example Application
		Enabling the Built-in Tag Helpers
		Transforming Anchor Elements
			Using Anchor Elements for Razor Pages
		Using the JavaScript and CSS Tag Helpers
			Managing JavaScript Files
				Selecting JavaScript Files
				Narrowing the Globbing Pattern
					Excluding Files
				Working with Content Delivery Networks
			Managing CSS Stylesheets
				Selecting Stylesheets
				Working with Content Delivery Networks
		Working with Image Elements
		Using the Data Cache
			Setting Cache Expiry
				Setting a Fixed Expiry Point
				Setting a Last-Used Expiry Period
				Using Cache Variations
		Using the Hosting Environment Tag Helper
		Summary
	Chapter 27: Using the Forms Tag Helpers
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Understanding the Form Handling Pattern
			Creating a Controller to Handle Forms
			Creating a Razor Page to Handle Forms
		Using Tag Helpers to Improve HTML Forms
			Working with Form Elements
				Setting the Form Target
			Transforming Form Buttons
		Working with input Elements
			Transforming the input Element type Attribute
			Formatting input Element Values
				Applying Formatting via the Model Class
			Displaying Values from Related Data in input Elements
		Working with label Elements
		Working with Select and Option Elements
			Populating a select Element
		Working with Text Areas
		Using the Anti-forgery Feature
			Enabling the Anti-forgery Feature in a Controller
			Enabling the Anti-forgery Feature in a Razor Page
			Using Anti-forgery Tokens with JavaScript Clients
		Summary
	Chapter 28: Using Model Binding
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Understanding Model Binding
		Binding Simple Data Types
			Binding Simple Data Types in Razor Pages
			Understanding Default Binding Values
		Binding Complex Types
			Binding to a Property
			Binding Nested Complex Types
				Specifying Custom Prefixes for Nested Complex Types
			Selectively Binding Properties
				Selectively Binding in the Model Class
		Binding to Arrays and Collections
			Binding to Arrays
				Specifying Index Positions for Array Values
			Binding to Simple Collections
			Binding to Dictionaries
			Binding to Collections of Complex Types
		Specifying a Model Binding Source
			Selecting a Binding Source for a Property
			Using Headers for Model Binding
			Using Request Bodies as Binding Sources
		Manually Model Binding
		Summary
	Chapter 29: Using Model Validation
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Understanding the Need for Model Validation
		Explicitly Validating Data in a Controller
			Displaying Validation Errors to the User
			Displaying Validation Messages
				Configuring the Default Validation Error Messages
			Displaying Property-Level Validation Messages
			Displaying Model-Level Messages
		Explicitly Validating Data in a Razor Page
		Specifying Validation Rules Using Metadata
			Creating a Custom Property Validation Attribute
		Performing Client-Side Validation
		Performing Remote Validation
			Performing Remote Validation in Razor Pages
		Summary
	Chapter 30: Using Filters
		Preparing for This Chapter
			Enabling HTTPS Connections
			Dropping the Database
			Running the Example Application
		Using Filters
			Using Filters in Razor Pages
		Understanding Filters
		Creating Custom Filters
			Understanding Authorization Filters
				Creating an Authorization Filter
			Understanding Resource Filters
				Creating a Resource Filter
				Creating an Asynchronous Resource Filter
			Understanding Action Filters
				Creating an Action Filter
				Implementing an Action Filter Using the Attribute Base Class
				Using the Controller Filter Methods
			Understanding Page Filters
				Creating a Page Filter
				Using the Page Model Filter Methods
			Understanding Result Filters
				Understanding Always-Run Result Filters
				Creating a Result Filter
				Implementing a Result Filter Using the Attribute Base Class
			Understanding Exception Filters
			Creating an Exception Filter
		Managing the Filter Lifecycle
			Creating Filter Factories
			Using Dependency Injection Scopes to Manage Filter Lifecycles
		Creating Global Filters
		Understanding and Changing Filter Order
			Changing Filter Order
		Summary
	Chapter 31: Creating Form Applications
		Preparing for This Chapter
			Dropping the Database
			Running the Example Application
		Creating an MVC Forms Application
			Preparing the View Model and the View
			Reading Data
			Creating Data
			Editing Data
			Deleting Data
		Creating a Razor Pages Forms Application
			Creating Common Functionality
			Defining Pages for the CRUD Operations
		Creating New Related Data Objects
			Providing the Related Data in the Same Request
			Breaking Out to Create New Data
		Summary
Part IV: Advanced ASP.NET Core Features
	Chapter 32: Creating the Example Project
		Creating the Project
			Adding NuGet Packages to the Project
		Adding a Data Model
			Preparing the Seed Data
			Configuring Entity Framework Core Services and Middleware
			Creating and Applying the Migration
		Adding the Bootstrap CSS Framework
		Configuring the Services and Middleware
		Creating a Controller and View
		Creating a Razor Page
		Running the Example Application
		Summary
	Chapter 33: Using Blazor Server, Part 1
		Preparing for This Chapter
		Understanding Blazor Server
			Understanding the Blazor Server Advantages
			Understanding the Blazor Server Disadvantages
			Choosing Between Blazor Server and Angular/React/Vue.js
		Getting Started with Blazor
			Configuring ASP.NET Core for Blazor Server
				Adding the Blazor JavaScript File to the Layout
				Creating the Blazor Imports File
			Creating a Razor Component
				Using a Razor Component
		Understanding the Basic Razor Component Features
			Understanding Blazor Events and Data Bindings
				Handling Events from Multiple Elements
				Processing Events Without a Handler Method
				Preventing Default Events and Event Propagation
			Working with Data Bindings
				Changing the Binding Event
				Creating DateTime Bindings
		Using Class Files to Define Components
			Using a Code-Behind Class
			Defining a Razor Component Class
		Summary
	Chapter 34: Using Blazor Server, Part 2
		Preparing for This Chapter
		Combining Components
			Configuring Components with Attributes
				Setting and Receiving Bulk Configuration Settings
				Configuring a Component in a Controller View or Razor Page
			Creating Custom Events and Bindings
				Creating a Custom Binding
		Displaying Child Content in a Component
			Creating Template Components
			Using Generic Type Parameters in Template Components
				Using a Generic Template Component
				Adding Features to the Generic Template Component
				Reusing a Generic Template Component
			Cascading Parameters
		Handling Errors
			Handling Connection Errors
			Handling Uncaught Application Errors
		Summary
	Chapter 35: Advanced Blazor Features
		Preparing for This Chapter
		Using Component Routing
			Preparing the Razor Page
			Adding Routes to Components
				Setting a Default Component Route
			Navigating Between Routed Components
			Receiving Routing Data
			Defining Common Content Using Layouts
				Applying a Layout
		Understanding the Component Lifecycle Methods
			Using the Lifecycle Methods for Asynchronous Tasks
		Managing Component Interaction
			Using References to Child Components
			Interacting with Components from Other Code
			Interacting with Components Using JavaScript
				Invoking a JavaScript Function from a Component
				Retaining References to HTML Elements
				Invoking a Component Method from JavaScript
				Invoking an Instance Method from a JavaScript Function
		Summary
	Chapter 36: Blazor Forms and Data
		Preparing for This Chapter
			Dropping the Database and Running the Application
		Using the Blazor Form Components
			Creating Custom Form Components
			Validating Form Data
			Handling Form Events
		Using Entity Framework Core with Blazor
			Understanding the Entity Framework Core Context Scope Issue
				Discarding Unsaved Data Changes
				Creating New Dependency Injection Scopes
			Understanding the Repeated Query Issue
				Managing Queries in a Component
		Performing Create, Read, Update, and Delete Operations
			Creating the List Component
			Creating the Details Component
			Creating the Editor Component
		Extending the Blazor Form Features
			Creating a Custom Validation Constraint
			Creating a Valid-Only Submit Button Component
		Summary
	Chapter 37: Using Blazor Web Assembly
		Preparing for This Chapter
			Dropping the Database and Running the Application
		Setting Up Blazor WebAssembly
			Creating the Shared Project
			Creating the Blazor WebAssembly Project
			Preparing the ASP.NET Core Project
			Adding the Solution References
			Opening the Projects
			Completing the Blazor WebAssembly Configuration
				Setting the Base URL
			Testing the Placeholder Components
		Creating a Blazor WebAssembly Component
			Importing the Data Model Namespace
			Creating a Component
				Navigating in a Blazor WebAssembly Component
				Getting Data in a Blazor WebAssembly Component
			Creating a Layout
			Defining CSS Styles
		Completing the Blazor WebAssembly Form Application
			Creating the Details Component
			Creating the Editor Component
		Summary
	Chapter 38: Using ASP.NET Core Identity
		Preparing for This Chapter
		Preparing the Project for ASP.NET Core Identity
			Preparing the ASP.NET Core Identity Database
				Configuring the Database Connection String
			Configuring the Application
			Creating and Applying the Identity Database Migration
		Creating User Management Tools
			Preparing for User Management Tools
			Enumerating User Accounts
			Creating Users
				Validating Passwords
				Validating User Details
			Editing Users
			Deleting Users
		Creating Role Management Tools
			Preparing for Role Management Tools
			Enumerating and Deleting Roles
			Creating Roles
			Assigning Role Membership
		Summary
	Chapter 39: Applying ASP.NET Core Identity
		Preparing for This Chapter
		Authenticating Users
			Creating the Login Feature
			Inspecting the ASP.NET Core Identity Cookie
			Creating a Sign-Out Page
			Testing the Authentication Feature
			Enabling the Identity Authentication Middleware
		Authorizing Access to Endpoints
			Applying the Authorization Attribute
			Enabling the Authorization Middleware
			Creating the Access Denied Endpoint
			Creating the Seed Data
			Testing the Authentication Sequence
		Authorizing Access to Blazor Applications
			Performing Authorization in Blazor Components
			Displaying Content to Authorized Users
		Authenticating and Authorizing Web Services
			Building a Simple JavaScript Client
			Restricting Access to the Web Service
			Using Cookie Authentication
			Using Bearer Token Authentication
				Preparing the Application
			Creating Tokens
			Authenticating with Tokens
			Restricting Access with Tokens
			Using Tokens to Request Data
		Summary
Index