A Special Group Presentation on Blazor Architecture - Episode 138

Today on The Azure DevOps Podcast, Jeffrey Palermo is sharing an exclusive presentation on Blazor Architecture Patterns.

Blazor is one of the new frameworks that has a lot to offer and is bringing many unique aspects together. With there already being so many fantastic developer tutorials and how-to's on Blazor, Jeffrey is instead going to be focusing on an architectural look at Blazor. Specifically, how the architecture works, as well as how you, as a developer, should be thinking about Blazor so that when you do choose to make use of it in its various forms, you can make the appropriate choice for your situation.

Jeffrey covers a variety of topics in this presentation and it is jam-packed full of tips, advice, techniques, tools, resources, and how-tos! He speaks about the patterns that are appropriate for every Blazor architect to consider, how the different flavors of Blazor operate at the architectural level, how Blazor handles memory management, the high-level hub-and-spoke architecture and how it can apply to a Blazor application, eventing throughout the user interface, how to test Blazor applications, and the unique things you need to do when monitoring a Blazor application when it's running in production.

Be sure to tune in as this presentation is beneficial for all .NET developers and those who make use of the Microsoft platform!

Topics of Discussion:

[:38] Be sure to visit AzureDevOps.Show for past episodes and show notes.

[:50] About The Azure DevOps Podcast, Clear Measure, the new podcast Architect Tips, and Jeffrey's offer to speak at virtual user groups.

[1:17] About today's special episode.

[1:35] Jeffrey's introduction to his special group presentation on Blazor architecture.

[2:32] What this presentation will be about.

[3:11] Jeffrey introduces himself and shares about his developer background.

[3:58] The topics that this presentation will be covering.

[4:55] If you would like an electronic copy of Jeffrey's book, .NET DevOps for Azure, send him an email at Jeffrey@Clear-Measure.com! You can also obtain a print copy anywhere books are sold.

[5:32] About The Azure DevOps Podcast.

[6:08] Getting started with Blazor: an overview.

[9:00] The first step: source control.

[11:50] How the Blazor Server-Side architecture works.

[16:57] Settings that are important to get right in order for a Blazor Server-Side app to work properly.

[20:48] Settings that are important for Blazor WebAssembly.

[22:44] How to choose between Blazor Server-Side and Blazor WebAssembly.

[25:21] How to handle memory management in Blazor WebAssembly and Blazor Server-Side.

[31:26] Entity Framework for Blazor Server-Side.

[34:30] About the hub-and-spoke pattern and how it can apply to a Blazor architecture.

[37:19] A word from Azure DevOps Podcast's sponsor: Clear Measure.

[37:51] Check out PlantUML if you are looking for a way to have design diagrams or architectural diagrams that are versionable that can be stored with your codebase.

[39:01] The main conduit from the user interface into the application.

[39:59] Jeffrey's favorite under-the-covers library right now for integrating and routing and integration for IOC Containers: the MediatR Library.

[40:53] Jeffrey talks component libraries and gives his recommendations around them.

[42:11] Why you need to think about all of the methods that your developers are using so that they are successful.

[42:46] Jeffrey addresses a crosscutting concern that the Bus can give developers.

[43:50] Jeffrey talks UI eventing within Blazor.

[48:20] The speed and performance of Blazor Server-Side when loading a screen that's a little bit long.

[49:46] How to refresh your browser pages in the DOM a lot quicker.

[51:59] Broadcasted events: how to do them across many users of the same application.

[55:12] Why you need to test your Blazor components.

[57:14] The tests that have to run in a fully deployed environment of your application, and the three steps to continuous integration.

[1:00:16] Operations and monitoring in Blazor.

[1:02:51] Monitoring and metrics in Blazor.

[1:08:33] Jeffrey wraps up the presentation.

Mentioned in this Episode:

Architect Tips — New video podcast!

Azure DevOps

Clear Measure (Sponsor)

.NET DevOps for Azure: A Developer's Guide to DevOps Architecture the Right Way, by Jeffrey Palermo — Available on Amazon!

bit.ly/dotnetdevopsebook — Click here to download the .NET DevOps for Azure ebook!

Jeffrey Palermo's Youtube

Jeffrey Palermo's Twitter — Follow to stay informed about future events!

The Azure DevOps Podcast's Twitter: @AzureDevOpsShow

Visual Studio

nopCommerce

Carl Franklin's Blazor Train

DevExpress

Git

WebAssembly

SignalR

Lamar

Entity Framework

PlantUML

MediatR Library

Telerik

Radzen

BU Responsive Framework

Selenium

ASP.NET MVC

Want to Learn More?

Visit AzureDevOps.Show for show notes and additional episodes.