Recently, I have started learning Blazor. I often learn new technologies because they draw my attention at some point and are interesting, but this time there were two reasons why I decided to learn Blazor: it is not only an interesting and new technology (at least at the time of writing this article), but it also allows developing an interactive web UIs using a C# programming language (which I already know quite well). Although I wouldn’t choose it for big commercial projects as it’s not yet a mature and time-tested technology, I have a feeling it will be a great fit for my new personal project.
[wpsm_toplist]
What are Blazor benefits and why I’m going to use it
So here’s why I think Blazor is a great fit for my project:
[wpsm_list type=”arrow”]
- Blazor components are implemented using C#, HTML, and CSS (no need to learn any JavaScript frameworks or libraries, like Angular or React).
- Blazor supports the following features out-of-the-box: routing, dependency injection, globalization, localization, forms validation, security, data binding, event handling, and many more.
- I can run Blazor applications on WebAssembly (directly in the browser) or the server.
- Built on open Web Standards.
- It’s based on .NET, so I can re-use existing .NET code.
- It’s cross-platform, so I can containerize the Blazor application.
- I can call JavaScript APIs and libraries if need be.
- It’s free and open source.
[/wpsm_list]
You also mentioned WebAssembly… What is it?
WebAssembly is a way to run bytecode in a browser inside the JavaScript runtime sandbox. You can compile any type of code, like C++ or C#, to WebAssembly bytecode and run it in a browser at near-native speed without the need for a plugin, and that is because WebAssembly is a native part of all the major browsers, including mobile browsers. Here’s how WebAssembly creators explains it:
WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable target for compilation of high-level languages like C/C++/Rust, enabling deployment on the web for client and server applications.
Below, I will give a list of some Blazor online courses that I am going to watch to learn Blazor so I can then go and implement my project with it.
[wpsm_video]https://www.youtube.com/watch?v=6Y3W94_8scw[/wpsm_video]
Blazor: The Big Picture course
I have already watched this course as my entry point to this technology and I recommend you do the same as it will give you all you need to get started with the technology.
Here is what is covered in this course. First, you’ll learn what Blazor actually is and how it works. Next, you’ll learn why you should use Blazor. You’ll also learn how to get your environment ready and how to create your first Blazor app. And finally, you’ll learn about the different architecture types that you can use to develop Blazor apps. You’ll learn about the difference between client-side Blazor, Blazor WebAssembly, and server-side Blazor, Blazor Server. Along the way, you’ll see all of these concepts through some demos.
Here’s what you’ll learn in this course:
[wpsm_list type=”arrow”]
- You will know exactly what Blazor is.
- How Blazor relates to WebAssembly.
- Application architecture difference: Blazor Server vs Blazor WebAssembly.
- Difference between Blazor and other single-page application (SPAs) technologies.
[/wpsm_list]
Prerequisites
The author says you don’t need to have any prior software development experience to watch this course. However, my opinion is different. In case you are a complete beginner in web development, I would recommend you to take some programming basics course on Pluralsight or LinkedIn Learning platform. Blazor applications are developed using C# programming language, so make sure you have at least the basic knowledge of it.
Duration: half an hour
Available here: link to the Pluralsight course
WebAssembly: The Big Picture course
Blazor applications run on WebAssembly. So in this course, you’ll learn what WebAssembly is, where it came from, and why it is important. In the first module, you’ll start by taking a look at where WebAssembly came from and who is behind it. Then, you’re going to familiarize yourself with it more and you’ll know what WebAssembly is and what some of its use cases are. And finally, you’ll learn how you can go about creating applications that use WebAssembly.
This course is created by the same author who created the Blazor: The Big Picture course, so after watching the big picture course, I was keen to start watching this one as I knew this author was great.
Here’s what you’ll learn in this course:
[wpsm_list type=”arrow”]
- What WebAssembly is and where did it come from.
- Why WebAssembly is a big deal.
[/wpsm_list]
Prerequisites
The author says you don’t need any prior web development experience, however, to at least have a little grasp of how things fit together, you should have some understanding of web development and know at least one programming language.
Duration: 40 minutes
Available here: link to the Pluralsight course
Blazor: Getting Started course
Now that the theory is learned, it’s time for getting your hands dirty. This is a practical course to learn all about Blazor. In this Getting Started course, you’re building a fully working Blazor application. When I say ‘a fully working application’, I mean you’ll see how to build the application from the very first steps, such as creating a new project in Visual Studio, then spending quite a lot of time coding the different pages of the application and adding many different features to it, to the deployment of the application.
Here’s what you’ll learn in this course:
There were many things that I liked about this Blazor practical course. The author will start the practical part of this course by explaining different Blazor application hosting models and how to debug Blazor applications. Also, this course has a lot of demos, for instance, how you can work with the HttpClient to call RESTful APIs, how to create forms, and how data binding and validation work, and, of course, the data persistence.
At the end of the course, you’ll see how to deploy your application using Microsoft Azure services – the App Service for API deployment, Azure SignalR Service (it’s used by the Blazor engine behind the scenes), and Azure SQL Database. Although the Microsoft Azure was used to deploy the applications, the Blazor application deployment isn’t limited by that.
Prerequisites:
This course provides plenty of information and concepts that you might not be familiar with yet. To fully understand the course material, I would strongly encourage you to go and learn C# programming language as well as some of the Microsoft Azure services, such as Azure App Services and Azure SignalR Service. You should also learn the SQL database programming if you are not familiar with it yet.
Duration: 2 hours 50 minutes
Available here: link to the Pluralsight course
Creating Blazor Components course
Another practical course on the Blazor topic. This is a dedicated course covering specifically the Blazor Components topic. Blazor Components part is an essential topic to know about when creating Blazor applications. To be fair, I was happy about the course content itself, it was really useful and informative, however, it could be a bit longer as I enjoyed watching this course and listening to what the author had to say about the technology. All in all, the course still provides plenty of useful information for you to get a good understanding of the Blazor Components, and to be able to write the components on your own.
Here’s what you’ll learn in this course:
[wpsm_list type=”arrow”]
- Component basics.
- How components can interact using a multitude of features.
- Re-using components.
- Internals of Blazor Components.
[/wpsm_list]
The author, Roland Guijt, is a great author and has authored many other great courses on Pluralsight, covering topics like ASP.NET Core, Identity, SignalR, Microservices, TypeScript, and many more. I encourage you to check them out.
Prerequisites:
The author says that you’ll need to have a getting started knowledge of Blazor, which I couldn’t agree more with, however, for you to fully understand everything that the course provides, you should also have some C# programming language knowledge as well as ASP.NET Core / Razor would be useful.
Duration: 1 hour 20 minutes
Available here: link to the Pluralsight course
Designing and Building Enterprise Blazor Applications course
The next course on the list is also a practical course. This course is created by another great Pluralsight author Alex Wolf. I always enjoy watching his in-depth courses on various topics, mainly around the .NET. What this course provides is what was mentioned in the very first two courses that were mainly theoretical, whereas this course will give you in-depth practical knowledge.
Here’s what you’ll learn in this course:
[wpsm_list type=”arrow”]
- You will focus on building more of real-world concepts, rather than building yet another Hello World application.
- You will learn how to design and build components and applications in a sustainable way.
- You’ll explore important architectural topics, such as dependency injection and routing in-depth.
- You’ll learn how to consume and share components in a re-usable way to enhance productivity.
- You will also learn how the HTTP communication works in Blazor.
- Advanced form concepts.
[/wpsm_list]
Prerequisites:
The author has defined that you should be familiar with the basic concepts of Blazor, also HTML and CSS. I would also explicitly outline some other prerequisites, such as C# and .NET knowledge in general, some .NET design patterns. You should also be familiar with the dependency injection concept (at least understand what it is for).
Duration: 2 hour 30 minutes
Available here: link to the Pluralsight course
Authentication and Authorization in Blazor Applications course
This is a practical course, and it’s one of those must-watch courses. Knowing how to use one or another technology, or knowing how to write some application is just one side of the medal. You need to be prepared to secure your Blazor application before it gets deployed to the wild Internet. This course is created by a great author, Kevin Dockx, who has created plenty of more useful courses covering various topics.
Here’s what you’ll learn in this course:
[wpsm_list type=”arrow”]
- You will start gaining an understanding of the security mechanisms available for you to start securing your Blazor application. Also, you’ll learn what issues you can expect related to the security mechanisms.
- You will learn how to implement the cookie-based authentication using ASP.NET Core Identity framework.
- You will learn how to implement the token-based authentication using OAuth2/OIDC.
- You will learn how to implement the token-based authentication using ASP.NET Core Identity framework.
- You will learn how to implement the Windows / Active Directory authentication.
- You will also learn how to implement the authorization.
[/wpsm_list]
Prerequisites:
As you may have guessed, the authentication and authorization topics are advanced topics. For you to be able to fully absorb all the information provided in this course, you’ll need to know all the other previously mentioned prerequisites. Also, security bits are not usually implemented by beginner developers as it’s a critical part of any application. Before you delve into this course, make sure you have a couple of years of experience in development.
Duration: 2 hour 30 minutes
Available here: link to the Pluralsight course
Conclusion
Hopefully, you’ll find this article useful. There are some more Blazor online courses available on other learning platforms like Udemy, however, the quality of those courses are not as good as on Pluralsight. It depends on what courses you are looking for, but when it comes to Microsoft related technologies — there’s no better platform out there to learn on than Pluralsight. In case you are thinking which Pluralsight subscription would be best for you, please read another article that will help you decide. I’m very confident in providing you with this list of great Blazor courses so that you can learn the technology very quickly. Just like I did.
