Blazor is a modern framework for building interactive web UIs using C# and .NET.
It allows developers to create dynamic and responsive web applications, leveraging the power and familiarity of the .NET ecosystem.
With Blazor, you can build everything from simple web pages to complex single-page applications (SPAs) and even full-fledged e-commerce websites.
By learning Blazor, you can build your own web applications, enhance your web development skills, and open doors to exciting career opportunities.
Finding a good Blazor course on Udemy can be challenging, as there are many options available, each with its own focus and teaching style.
You’re looking for a course that’s comprehensive, engaging, and taught by experienced instructors.
For the best Blazor course overall on Udemy, we recommend Blazor Bootcamp - .NET 6 E-Commerce Web App (WASM and Server).
This course provides a comprehensive journey into Blazor development, taking you from the basics to building a real-world e-commerce application.
It covers both Blazor WebAssembly and Blazor Server, along with essential technologies like Entity Framework Core, ASP.NET Core Web API, and Stripe integration, making it a valuable resource for any developer seeking to master Blazor.
While Blazor Bootcamp - .NET 6 E-Commerce Web App (WASM and Server) is our top pick, there are other excellent Blazor courses on Udemy catering to different skill levels and interests.
Keep reading to discover our recommendations for beginners, intermediate learners, and experts, and find the perfect Blazor course for your learning journey.
Blazor Bootcamp - .NET 6 E-Commerce Web App(WASM and Server)
You’ll start by learning the fundamentals of Blazor, including client-side and server-side Blazor, data binding, and creating reusable components.
As you progress, you’ll dive into more advanced topics like event handling, render fragments, attribute splatting, routing, and integrating JavaScript libraries like Toastr and SweetAlert.
The course covers building models, repositories, and data transfer objects (DTOs) using Entity Framework Core and AutoMapper.
You’ll learn to implement CRUD operations for categories and products, including file uploads, validations, and loading spinners.
The course also covers integrating third-party UI components like Syncfusion’s RichTextEditor and DataGrid.
To simulate a real-world scenario, you’ll build a Tangy API and consume it in both Blazor Server and Blazor WebAssembly projects.
You’ll implement features like shopping carts, order management, and Stripe payment integration.
Authentication and authorization are covered in-depth, including Identity, roles, and JSON Web Tokens (JWT).
You’ll learn to seed data using a DbInitializer and send emails with MailKit, MimeKit, or SendGrid.
Finally, the course guides you through deploying your application to Azure, covering Azure SQL Database, Blazor Server, API, and Blazor WebAssembly deployments.
Programming in Blazor - ASP.NET Core 5
You’ll start by learning the fundamentals of Blazor, including the differences between Blazor WebAssembly and Blazor Server-Side, and where you can use Blazor.
The course will guide you through setting up the development environment and introduce you to Razor, the syntax for building Blazor components.
From there, you’ll dive into the core concepts of Blazor components, including parameters, events, data binding, and life cycle methods.
You’ll also learn about dependency injection, services, layouts, and how to interact with JavaScript and CSS.
The course covers essential topics like routing, forms, and validations.
You’ll build components for various form elements, including input fields, selectors, and typeahead (autocomplete).
Additionally, you’ll learn how to reorder elements in a list and build a movie filtering component.
One of the key aspects of the course is communicating with the back-end using HTTP and Entity Framework Core.
You’ll create a database, work with genres, people, and movies, and even learn how to save images in Azure Storage or locally.
Security is a crucial aspect of web development, and the course dedicates a module to it.
You’ll explore the authentication state provider, learn about AuthorizeView and Authorize components, configure Identity in ASP.NET Core, and build components for registration, login, and logout.
The course also covers roles, JWT (JSON Web Tokens), background tasks, and automatic logout for inactive users.
Deployment is another important topic covered in the course.
You’ll learn how to deploy your Blazor applications to Azure App Service, Azure Storage, and IIS (Internet Information Services).
The course also covers continuous delivery with Azure DevOps.
Sharing code and creating Razor Class Libraries is another valuable skill you’ll acquire.
You’ll learn how to create shared components, access CSS and JavaScript files, and work with routable components and cascading parameters.
The course also explores Blazor Server and dual-architecture applications, allowing you to leverage the benefits of both Blazor WebAssembly and Blazor Server-Side.
Finally, you’ll learn about internationalization, including multi-language support, handling culture-dependent data like dates and numbers, and managing error messages in different languages.
ASP.NET Core 6.0 Course - MVC - Blazor - Razor - EF Core
You’ll start by learning the basics of ASP.NET and setting up your development environment.
Then, you’ll dive into building web apps using different approaches like MVC, Razor Pages, and Blazor.
With MVC, you’ll learn how to create a project, add controllers and views, work with models and view models, and handle form data.
The course covers the MVC pattern in-depth, ensuring you understand this fundamental concept.
Moving on to Razor Pages, you’ll build a pizza ordering application.
This hands-on project will teach you how to set up pages, use the MVVM pattern, create models and view models, work with databases using Entity Framework Core, and save and display data.
The Blazor section is equally engaging, where you’ll build interactive web apps using reusable components.
You’ll explore Blazor’s lifecycle, data binding, event handling, forms and validations, layouts, and CSS isolation.
Additionally, you’ll learn to call web APIs, upload and download files, and implement globalization and localization.
The course then dives into data-driven web apps, teaching you how to use Entity Framework Core and SQL with MVC.
You’ll also learn to create your own RESTful APIs, complete with documentation using Swagger/OpenAPI, error handling, and minimal APIs.
Security and identity are crucial topics covered through an invoice management system project.
You’ll implement authentication, authorization policies and handlers, manage roles and permissions, and learn about dependency injection.
Towards the end, you’ll explore advanced topics like seeding data, managing secrets, charting and graphing, and deploying your app to Azure App Services.
Throughout the course, you’ll work on practical projects, reinforcing your learning with challenges and quizzes.
Make an E-Commerce Website with Blazor WebAssembly in .NET 6
This course is a comprehensive guide to building a full-featured e-commerce application using Blazor WebAssembly and .NET 6.
You will start by setting up the development environment, including installing .NET and Visual Studio.
The course then walks you through creating a Blazor WebAssembly project and understanding its structure.
Next, you will build a “walking skeleton” of the e-commerce website, covering essential features like displaying products, creating a web API, integrating with a database using Entity Framework Core, and implementing CRUD operations.
Along the way, you’ll learn best practices such as using services with dependency injection and implementing a service response pattern.
The course dives deep into product management, teaching you how to display product details, handle categories, variants, search functionality, featured products, and pagination.
You’ll also implement a shopping cart using local storage and later migrate it to a database for authenticated users.
User authentication is a crucial aspect covered in the course, where you’ll learn to implement registration, login, and JSON Web Token (JWT) authentication.
You’ll also build user profiles and enable features like changing passwords.
Once the core functionality is in place, the course guides you through integrating a payment system using Stripe Checkout.
You’ll learn how to create a checkout session, handle successful payments, and fulfill orders.
The course also covers adding delivery addresses for orders and building an admin dashboard for managing categories, product types, and products themselves.
You’ll implement CRUD operations for these entities, allowing administrators to add, update, and delete them.
Additionally, the course includes a bonus section on uploading images and an introduction to MudBlazor, a popular UI library for Blazor applications.
You’ll learn how to associate multiple images with products and display them using MudBlazor components.
Throughout the course, you’ll work with various .NET technologies, including Entity Framework Core, Web APIs, dependency injection, and authentication middleware.
You’ll also gain experience with client-side development using Blazor WebAssembly, handling HTTP requests, and working with components and services.
Blazor - The Complete Guide (WASM & Server .NET Core 5)
You’ll start with the basics of Blazor, including one-way and two-way data binding, working with dropdowns and loops, and creating reusable components.
The course then dives into more advanced topics like lifecycle methods, event callbacks, render fragments, attribute splatting, and cascading parameters.
As you progress, you’ll learn how to implement routing, work with databases using Entity Framework Core, and build forms with validation.
The course also covers integrating JavaScript libraries like Toastr and SweetAlert into your Blazor applications.
One of the highlights is the hotel room management project, where you’ll build a full-featured application with CRUD operations, file uploads, image handling, and text editing using Quill.
You’ll also learn about authentication and authorization using ASP.NET Core Identity.
The course then shifts gears to building a .NET 5 API, complete with endpoints for hotel rooms, user registration, and sign-in functionality.
You’ll integrate this API with a Blazor WASM client application, covering topics like local storage, HTTP clients, and loading indicators.
Moving forward, you’ll build a hotel booking system with room details, order management, and Stripe integration for secure payments.
The course also covers advanced authentication and authorization techniques for Blazor WASM applications.
Additionally, you’ll learn how to send emails using MailJet, implement authorization scenarios, work with third-party components like Radzen, and manage room bookings.
Finally, the course guides you through deploying your Blazor applications to Azure.
Throughout the course, you’ll work on assignments and projects that reinforce the concepts covered, ensuring you gain practical experience with Blazor development.
Complete Blazor (WASM & Server) and ASP.NET API Development
You’ll start by setting up your development environment, including Visual Studio, SQL Server, and GitHub.
This ensures you have the right tools for the job.
Next, you’ll dive into building an ASP.NET Core Web API project, configuring logging with Serilog, and enabling CORS.
You’ll then scaffold a database and create API controllers for managing authors and books, complete with AutoMapper for object mapping and DTOs for data transfer.
A crucial part of the course is implementing Identity and JWT authentication.
You’ll learn to add Identity Core Libraries, seed test users and roles, set up an authentication controller, and implement JSON Web Tokens (JWT) for secure authentication.
With the API in place, you’ll create a Blazor Server client app.
You’ll explore the project structure, set up an HTTP client using NSwag Studio, and implement user registration and login functionality.
The course then guides you through building comprehensive UI components for managing authors and books in the Blazor Server app.
You’ll create index, create, update, view, and delete components, complete with file upload capabilities for books.
You’ll also learn to add authorization restrictions.
Moving on, you’ll create a Blazor WebAssembly client app, exploring its differences from Blazor Server.
You’ll transfer your existing code and learn about Progressive Web Applications (PWAs).
The course covers architectural considerations like the Repository Pattern, virtualization, and code-behind component files.
Finally, you’ll deploy your applications to Microsoft Azure, a crucial skill for production deployments.
You will learn by doing, building a complete web application from start to finish.
Blazor WebAssembly Full Stack Bootcamp with .NET 5
You’ll start by learning the fundamentals of Blazor WebAssembly, including creating your first Razor components, handling component communication, and working with services.
The course then dives into building a game application, where you’ll learn how to create user interfaces, handle forms and validation, and implement authentication using JSON Web Tokens (JWT).
Along the way, you’ll explore the Model-View-Controller (MVC) pattern, work with Web APIs and Entity Framework for data access, and integrate with databases like SQL Server and SQLite.
As you progress, you’ll learn advanced topics like implementing one-to-many relationships, creating leaderboards, handling battles and battle histories, and deploying your application to a Windows Server using Internet Information Services (IIS).
The course also covers migrating from .NET Core 3.1 to .NET 5, taking advantage of the latest features and improvements.
Throughout the course, you’ll gain hands-on experience with essential tools and technologies like Visual Studio, Postman, Git, and GitHub.
You’ll learn how to work with CSS for styling, handle asynchronous calls, and leverage dependency injection for better code organization.
Master Blazor Development: Build Inventory Management System
This course starts with an introduction to Blazor and its project structure, covering how Blazor Server works.
You’ll learn about Clean Architecture principles and the Null Reference Type in .NET 6.
From there, the course dives into the core functionality of an Inventory Management System.
You’ll build an Inventory List page, complete with search and filtering capabilities.
The course covers best practices for SPA components, data binding, event handling, and component parameters.
As you progress, you’ll implement features like adding, editing, and purchasing inventories.
The course teaches you how to use EditForm for data validation and NavigationManager for routing.
You’ll also learn about async programming and why it’s essential in Blazor applications.
The course covers managing products, including listing, adding, and editing them.
You’ll learn about the Decoration Pattern and CSS Isolation for styling components.
Additionally, you’ll build an AutoComplete component and use it in various parts of the application.
Moving on, you’ll implement features like producing and selling products, with custom validations for inventory quantities.
The course also covers JavaScript interop, allowing you to integrate JavaScript functionality into your Blazor app.
Reporting is a crucial aspect of any inventory management system, and this course covers it in depth.
You’ll build inventory and product transaction reports, with the ability to print them.
The course then shifts gears to data persistence using Entity Framework Core.
You’ll learn how to configure DbContext, run migrations, and implement repositories for inventories, products, and transactions.
The course also covers using DbContextFactory for better performance.
Security is an essential aspect of any web application, and this course covers it using ASP.NET Core Identity.
You’ll learn how to install and configure Identity, scaffold registration and login pages, and manage user permissions with policies and claims.
Finally, the course covers enhancing the user interface with Bootstrap, including adding a responsive navbar with expandable sub-navigation menus.
Master Blazor Development: Build an e-Commerce App
The course starts by introducing you to the ASP.NET Core platform and how a Blazor app is bootstrapped, giving you a solid foundation.
You’ll learn about project structure, adding dynamic content, and the three main aspects: view, state, and event.
From there, you’ll dive into developing a real-world e-commerce app, starting with screen mockups and component breakdown.
The course guides you through implementing the core business layer, use cases layer, and data store plugins, including an in-memory data store.
You’ll create components for searching products, implementing filtering, and styling with Bootstrap.
The course goes in-depth into Blazor, covering data binding, communication between components, parameters, route parameters, EventCallback, cascading parameters, referencing child components, RenderFragment, component lifecycle events, forms and validations, state management with the Observer pattern, and dependency injection.
You’ll learn about dependency problems, the Dependency Inversion Principle, and Inversion of Control, as well as how to manage dependencies in Blazor Server and WebAssembly apps.
Next, you’ll build a customer portal by reorganizing projects for clean architecture, implementing order entities and business rules, shopping cart abstraction, and use cases like adding products to the cart, viewing the cart, deleting products, and updating quantities.
You’ll create components for order line items, order summary, shopping cart state management, and order confirmation.
The course also covers building an admin portal with admin use cases and screens, adding authentication and authorization, configuring middleware and DI, authentication endpoints, login and sign-out screens, and processing orders with the admin’s username.
You’ll learn about built-in authentication and authorization.
Additionally, you’ll connect C# to a SQL database using Dapper, covering SQL statement basics, reading, creating, updating, and deleting with Dapper, and implementing a new data store plugin with SQL and Dapper for the e-commerce app.
The course provides source code files and instructions for running the app with both the in-memory and SQL data stores.
Build ASP.NET Blazor apps with a clean structure
The course starts by introducing Blazor, its hosting models, and the reasons to choose it.
You’ll then set up a sample project and learn the basics of components, data binding, event handling, and Razor syntax.
The course dives into more advanced topics like validation, routing, dependency injection, and working with services like UserManager.
You’ll build reusable components like dropdowns and learn techniques like cascading parameters and SASS styling.
A major part of the course focuses on managing application state and data access.
You’ll explore in-memory data storage, IndexedDB for client-side persistence, and integrating with a Web API for server-side data.
Authentication and authorization are covered in depth, including implementing authentication state providers.
Other key areas include JavaScript interoperability, displaying busy indicators and modals, and optimizations like unregistering event handlers.
The course also guides you through upgrading to newer .NET versions and leveraging newer features like CSS/JS isolation.
Throughout the course, you’ll work on a real-world project called “Organize” that puts these concepts into practice.
The project involves building a task management application with features like creating and managing items, user accounts, and data persistence.