MICROSOFT BLAZOR : building web applications in .net.

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Your First Blazor Project
	Installing Blazor Prerequisites
		.NET Core
		Visual Studio 2019
		Visual Studio Code
		Installing the Blazor Templates for VS/Code
	Generating Your Project with Visual Studio
		Creating a Project with Visual Studio
		Generating the Project with dotnet cli
		Running the Project
			The Home Page
			The Counter Page
			The Fetch Data Page
	Examining the Project’s Parts
		The Solution
		The Server
		The Shared Project
		The Client Blazor Project
			Routing
			Layout Components
	Debugging Client-Side Blazor
		Debugging with Visual Studio
		Debugging in Chrome
	The Client-Side Blazor Bootstrap Process
	The Server-Side Blazor Bootstrap Process
	Summary
Chapter 2: Data Binding
	A Quick Look at Razor
	One-Way Data Binding
		One-Way Data Binding Syntax
		Attribute Binding
		Conditional Attributes
	Event Handling and Data Binding
		Event Binding Syntax
		Event Arguments
		Using C# Lambda Functions
	Two-Way Data Binding
		Two-Way Data Binding Syntax
	Binding to Other Events: @bind:{event}
		Preventing Default Actions
		Stopping Event Propagation
		Formatting Dates
	Reporting Changes
	The Pizza Place Single-Page Application
		Create the PizzaPlace Project
		Add Shared Classes to Represent the Data
		Build the UI to Show the Menu
			Display the Menu
				Displaying a List of Data
				Converting Values
			Add Pizzas to the Shopping Basket
			Show the Shopping Basket
				Add a Package with Visual Studio
				Add a Package with Visual Studio Code
				Display the Shopping Basket
		Enter the Customer
			Debugging Tip
		Validate the Customer Information
			Let Entities Validate Themselves
			Use FormField and InputText to Enable Validation
			Show Validation Errors
			Customize the Validation Feedback
	Summary
Chapter 3: Components and  Structure for Blazor Applications
	What Is a Blazor Component?
		Examining the SurveyPrompt Component
		Building a Simple Alert Component with Razor
			Create a New Component with Visual Studio
			Create a New Component with Code
			Implement the Alert Component
		Separating View and View Model
			Create a DismissableAlert Component
		Understanding Parent-Child Communication
			Add a Timer Component
			Use Two-Way Component to Component Data Binding
			Better Use an EventCallback
		Referring to a Child Component
		Communicating with Cascading Parameters
			Use the CascadingValue Component
			Add the GrandMother Component
			Receive the Cascading Value
			Handle Changes
			Resolving Ambiguities
	Using Templated Components
		Create the Grid Templated Component
		Use the Grid Templated Component
		Specify the Type Parameter’s Type Explicitly
		Razor Templates
	Building a Component Library
		Create the Component Library Project
			With Visual Studio
			With Code
		Add Components to the Library
		Refer to the Library from Your Project
			Referring to Another Project with Visual Studio
			Referring to Another Project with Code
			Using the Library Components
			Styling Components in a Component Library
	Component Life Cycle Hooks
		OnInitialized and OnInitializedAsync
		OnParametersSet and OnParametersSetAsync
		SetParametersAsync
		OnAfterRender and OnAfterRenderAsync
		ShouldRender
		IDisposable
	Refactoring PizzaPlace into Components
		Create a Component to Display a List of Pizzas
		Show the ShoppingBasket Component
		Add the CustomerEntry Component
		Use Cascading Properties
			Examine the InputText Component Internals
			Catch EditContext from the EditForm
			Disable the Submit Button
	The Blazor Compilation Model
	Summary
Chapter 4: Services and Dependency Injection
	What Is Dependency Inversion?
		Understanding Dependency Inversion
		Using the Dependency Inversion Principle
		Adding Dependency Injection
		Applying an Inversion-of-Control Container
			Constructor Dependency Injection
			Property Dependency Injection
	Configuring Dependency Injection
		Singleton Dependencies
		Transient Dependencies
		Scoped Dependencies
		Disposing Dependencies
	Understanding Blazor Dependency Lifetime
		Client-Side Blazor Experiment
		Server-Side Blazor Experiment
		The Result of the Experiment
			Transient Lifetime
			Singleton Lifetime
			Scoped Lifetime
	Building Pizza Services
		Adding the MenuService and IMenuService Abstraction
		Ordering Pizzas with a Service
	Summary
Chapter 5: Data Storage and Microservices
	What Is REST?
		Understanding HTTP
		Universal Resource Identifiers and Methods
		HTTP Status Codes
	Invoking Server Functionality Using REST
		HTTP Headers
		JavaScript Object Notation
		Some Examples of REST Calls
	Building a Simple Microservice Using ASP.NET Core
		Services and Single Responsibility
		The Pizza Service
	What Is Entity Framework Core?
		Using the Code First Approach
		Preparing Your Project for Code First Migrations
			Finding Your Database Server’s Connection String
		Creating Your Code First Migration
		Generating the Database
	Enhancing the Pizza Microservice
	Testing Your Microservice Using Postman
		Installing Postman
		Making REST Calls with Postman
			Making a GET Request
			Inserting Pizzas with POST
	Summary
Chapter 6: Communication with Microservices
	Using the HttpClient Class
		Examining the Server Project
		Why Use a Shared Project?
		Looking at the Client Project
			How to Emulate a Slow Network in Chrome
	Understanding the HttpClient Class
		The HttpClientJsonExtensions Methods
			GetFromJsonAsync
			PostAsJsonAsync
			PutAsJsonAsync
	Retrieving Data from the Server
	Storing Changes
		Updating the Database with Orders
		Building the Order Microservice
		Talking to the Order Microservice
	Summary
Chapter 7: Single-Page Applications and Routing
	What Is a Single-Page Application?
	Using Layout Components
		Blazor Layout Components
		Selecting a @layout Component
		_Imports.razor
		Nested Layouts
	Understanding Routing
		Installing the Router
		The NavMenu Component
		The NavLink Component
	Setting the Route Template
		Using Route Parameters
		Filter URIs with Route Constraints
	Redirecting to Other Pages
		Navigating Using an Anchor
		Navigating Using the NavLink Component
		Navigating with Code
		Understanding the Base Tag
	Sharing State Between Components
	Summary
Chapter 8: JavaScript Interoperability
	Calling JavaScript from C#
		Providing a Glue Function
		Using IJSRuntime to Call the Glue Function
		Storing Data in the Browser with Interop
		Passing a Reference to JavaScript
	Calling .NET Methods from JavaScript
		Adding a Glue Function Taking a .NET Instance
		Adding a JSInvokable Method to Invoke
	Using Services for Interop
		Building the ILocalStorage Service
		The Counter with the LocalStorage Service
	Building a Blazor Chart Component Library
		Creating the Blazor Component Library
		Adding the Component Library to Your Project
		Adding Chart.js to the Component Library
			Verifying If the JavaScript Library Loaded Correctly
		Adding Chart.js Data and Options Classes
			The ChartOptions Class
			The LineChartData Class
		Registering the JavaScript Glue Function
		Providing the JavaScript Interoperability Service
		Implementing the LineChart Component
		Using the LineChart Component
	Summary
Index