Blazor Deep Dive - From Beginner to Advanced in .NET 8 (Learn ASP.NET Core Blazor in .NET 8 with Projects)

This complete course, "Blazor Deep Dive - From Beginner to Advanced in .NET 8," is meant for those developers who are hungry to master the deep internals of Blazor. The learning experience throughout this class is from the fundamental concepts to very advanced techniques.

"Blazor is a framework for building interactive client-side web UI with .NET. It allows you to build web applications using C# and HTML instead of JavaScript."

Getting started, you will begin with a simple outline of the Blazor structure and project layout. You will then continue by learning how to work on Server-Side Rendering using Blazor, how to create components, how to use Razor syntax, and, most importantly, how to manipulate data. Finally, in the last chapter, you will ultimately create a user-interactive experience end-to-end with both Server-side Blazor and WebAssembly-based Blazor, becoming a master of event handling, state management, and data binding.

Learn the more complex topics, such as component architecture, state management, authentication, and data access. And with the practical application of projects like the Server Management tool and To-Do List App, you can solidify your skills. Whether you are a beginner with Blazor or someone who wants to increase their skills, Blazor Deep Dive - From Beginner to Advanced in .NET 8 is the place where you can solidify your dynamic web application using .NET 8.

"Blazor lets you build interactive web UIs using C# instead of JavaScript. It's a feature of ASP.NET, the popular web development framework that extends the .NET developer platform with tools and libraries for building web apps."

Blazor Deep Dive - From Beginner to Advanced in .NET 8 Table of Contents:

1. What is Blazor (05:44)
2. Choices of Interactivity (08:31)
3. Blazor SSR Project Structure (13:09)
4. Two Types of Components (08:30)
5. Razor Syntax Implicit Razor Expression (06:41)
6. Razor Syntax Explicit Razor Expression (04:37)
7. Create a static data repository (02:39)
8. Razor Syntax Output list with looping (05:31)
9. Assignment 1: Output city buttons list (01:41)
10. Assignment 1: Answer (04:37)
11. Working with Static Resources (05:27)
12. Assignment 2: Create a routable component (01:03)
13. Assignment 2: Answer (04:05)
14. Route Parameters & Route Constraints (07:42)
15. Use OnParametersSet to receive parameter value (06:05)
16. Use Form and Input components to display and collect data (07:49)
17. Form submission and model binding (13:39)
18. Form Validations (08:40)
19. Navigation with NavigationManager & Dependency Injection (14:06)
20. Assignment 3: Add Server (00:55)
21. Assignment 3: Answer (07:04)
22. Use EditForm to delete data (09:26)
23. What is interactivity (05:28)
24. Use Enhanced Navigation in Blazor SSR for interactivity (05:40)
25. Use Enhanced form handling in Blazor SSR for interactivity (13:44)
26. What is Server Interactivity (08:28)
27. Enable Server Interactivity how to make a component interactive (08:30)
28. Interactivity Location (06:30)
29. Server Interactivity in Visual Studio project template (03:54)
30. Three main aspects of interactive components (05:06)
31. Event Handling (Passing Data) (10:52)
32. Assignment 4: Highlight current City (01:13)
33. Assignment: 4 Answer (03:14)
34. Update. state variables with Onchange event (09:46)
35. Two way data binding (06:51)
36. Interactive EditForm (03:52)
37. Use @key to improve list-rendering performance (05:26)
38. Use Virtualization to improve list-rendering performance (08:27)
39. Requirement of To do list app (04:51)
40. Display a list of tasks use case (10:09)
41. Add Task use case (07:19)
42. Input task name use case (03:55)
43. Mark task as completed use case (11:22)
44. Thinking in Components (04:42)
45. Extract the ServerList Component (07:23)
46. Use Component Parameters to communicate from parent to child components (08:36)
47. Assignment 5: Extract the Server Component (01:55)
48. Assignment 5: Answer (05:44)
49. Extract city components (07:52)
50. Use EventCallback to pass info from child to parent components (11:11)
51. Assignment 6: Componentize the search bar (01:27)
52. Assignment 6: Answer (07:19)
53. Reference a child component (06:53)
54. Reuse routable component as non-routable component (04:30)
55. Use if statement to output data conditionally (04:59)
56. Assignment 7: Display people online (01:00)
57. Assignment 7: Answer (03:30)
58. CSS Isolation (09:46)
59. Cascading Parameter theory (02:18)
60. Use cascading parameter to pass values down the component tree (06:43)
61. Cascading Parameter crossing render mode boundary (06:07)
62. Use templated components to create generic components (08:18)
63. Typed Templated Component (06:49)
64. Use html table in our RepeaterComponent (04:25)
65. Using QuickGrid to display our servers (12:10)
66. QuickGrid Sorting and Pagination (04:23)
67. Use arbitrary attributes to provide flexibility (05:37)
68. Componentize the List of Items (05:22)
69. Componentize the to do item (03:16)
70. Component Lifecycle Overview (08:35)
71. Component lifecycle events sequence Part 1 (09:21)
72. Component lifecycle events sequence Part 2 (05:13)
73. The problem of component initialization (05:02)
74. Trouble with Pre-Rendering (00:13)
75. The problem with OnParameterSet (05:28)
76. When does a component render (09:43)
77. The problem of ShouldRender (04:08)
78. Thread Safety & SynchronizationContext for Server Interactivity (14:14)
79. Static vs Interactive Routing (09:35)
80. Use NavigationLock to prevent navigation (09:38)
81. Multiple Page Directives (07:06)
82. Optional Parameters (07:35)
83. Query Strings (04:03)
84. State Management Overview (04:38)
85. Use URL to pass info across routable components (11:07)
86. Use browser storage to maintain states (13:18)
87. Use DI container to maintain states (08:57)
88. Use Observer Pattern to access states across component trees (04:25)
89. Implement state store with Observer pattern (15:08)
90. Dispose Subscribers (04:21)
91. WebAssembly Interactivity Locations (02:52)
92. Create a new project with WebAssembly Interactivity (07:41)
93. Mix Render Modes (06:04)
94. Life cycle events in WebAssembly Interactivity (04:39)
95. Browser Storage & Javascript InterOp (17:53)
96. Use DI container to maintain states for WASM components (06:49)
97. Debug WebAssembly Components (09:17)
98. Other Differences (00:44)
99. Overview of accessing DB from SSR or Server Interactivity (01:13)
100. Add NuGet Packages for using EF Core (04:42)
101. Create DBContext (05:11)
102. Configure connection strings and run migration (11:39)
103. Implement the ServersEFCoreRespository (11:04)
104. Use the plugin based repository (14:37)
105. Access DB from WebAssembly (03:27)
106. How Web API works (06:04)
107. Prepared Server Management CRUD code in WebAssembly (03:57)
108. Setup Firebase Realtime Database (03:27)
109. Use Postman to access the Web API endpoints (09:03)
110. Invoke API in C#(15:26)
111. Prepare Body in HttpRequest (06:34)
112. Implement the Api Repository (04:28)
113. Overview - How authentication works in Blazor (07:17)
114. All authentication scenarios (02:11)
115. Authentication in Blazor SSR (11:07)
116. User Registration (04:23)
117. Login process (03:59)
118. Authorization process (04:01)
119. Accessing the authentication ticket (08:23)
120. Authentication in Server Interactivity per page component (04:18)
121. Authentication in WebAssembly Interactivity per page component (04:00)
122. Authentication in Global Server Interactivity (05:04)
123. Authentication in Blazor Global WebAssembly Interactivity (08:44)
124. Secure our server-side Blazor app (05:28)
125. Policy-based authorization (06:36)
126. What is Pre-Rendering and Why (09:38)
127. Solution 1: Use OnAfterRender (06:47)
128. Solution 2: Disable Pre-Rendering (08:21)
129. Solution 3: Use PersistentComponentState (08:38)
130. Bonus Lecture (00:12)

Who is this course for?

1. C# developers who want to become a full-stack developer without needing to master JavaScript.
2. Developers who would like to have as little JavaScript as possible in their work and prefer Razor Pages/MVC instead.
3. Developers with some Blazor experience who want to fill in the gaps, especially around changes introduced with .NET 8.
4. Developers are curious about Microsoft's latest SPA framework—Blazor.

Click on the links below to Download Blazor Deep Dive - From Beginner to Advanced in .NET 8!