Blazor: About - What is SignalR and WASM?

Blazor is a web technology typically paired with a Microsoft ASP.NET Core server (WebAPI or RESTful API when using WebAssembly). It allows one to program in C# for both client and server side. It is implemented with two distinct architectures: client-side rendering and server-side rendering.

The client-side rendering, which relies upon WebAssembly, requires that more code be downloaded initially, but it is very efficient with regard to server-side operations, and this code need be downloaded only once. It is stateless. The client-side happens thanks to most browsers supporting a technology known as web assembly. The idea here is to offload processing from the server and onto the client thereby supporting more users.

The server-side rendering works more like a traditional HTTP server except that it is not stateless as there is a connection always open between the server and client. Also, the client code is prepared in the server’s memory and then sent to the client. This is less efficient, but there maybe some special applications that could benefit from such an architecture. The client page does not need to reload when changes are made. Only the "Document Object Model" is updated just like with the client-side architecture.

---

Blazor WebAssembly (Blazor WASM) is a framework for building interactive web applications using C# and .NET instead of JavaScript. Here are the key aspects of Blazor WebAssembly:

Overview

• Blazor: Part of the ASP.NET Core framework, Blazor enables developers to create rich, client-side web applications.
• WebAssembly (WASM): A binary instruction format that allows code written in languages other than JavaScript (like C#) to run in web browsers at near-native speed.

Key Features

• C# on the Client: Write client-side logic in C# instead of JavaScript.
• .NET Runtime in the Browser: Blazor WASM runs on a WebAssembly-based .NET runtime, allowing the execution of .NET code directly in the browser.
• Single-Page Applications (SPAs): Create SPAs with a seamless user experience, similar to those built with JavaScript frameworks like Angular, React, or Vue.
• Component-Based Architecture: Develop reusable UI components with C#, HTML, and CSS.
• Full-Stack Development with .NET: Share code between client and server, and use the same programming model and tools throughout the application.

How It Works

1. WebAssembly Download: When a Blazor WebAssembly app is accessed, the browser downloads a small .NET runtime along with the application's DLLs (compiled C# code) and dependencies.
2. Execution: The .NET runtime executes the DLLs, enabling the application to run client-side in the browser.
3. Interaction with JavaScript: Blazor allows for JavaScript interoperability, meaning C# code can call JavaScript functions and vice versa, allowing the use of existing JavaScript libraries.

Key Components

• Razor Components: The building blocks of a Blazor application, Razor components combine HTML markup with C# code to define reusable UI elements.
• Routing: Blazor provides a routing system to navigate between different components based on URLs.
• Dependency Injection: Blazor supports dependency injection, allowing services to be easily injected into components.

Development Workflow

1. Create a Blazor WebAssembly Project: Use tools like Visual Studio or the .NET CLI to create a new Blazor WebAssembly project.
2. Build Components: Develop Razor components that encapsulate the UI and logic.
3. Define Routing: Set up routing to navigate between different components.
4. Implement Services: Create and register services for business logic, data access, etc.
5. JavaScript Interop: Integrate with existing JavaScript libraries if needed.
6. Run and Debug: Use the integrated development environment (IDE) to run and debug the application locally.

Advantages

• Single Language: Use C# for both client-side and server-side code.
• Productivity: Leverage .NET ecosystem, libraries, and tools.
• Performance: WebAssembly provides near-native execution speed.
• Code Sharing: Share code between client and server, reducing duplication and maintenance.

Limitations

• Initial Load Time: The initial download size can be large, affecting the startup time.
• Browser Compatibility: While WebAssembly is supported by most modern browsers, there might be limitations or differences in behavior.
• Ecosystem Maturity: Blazor and WebAssembly are relatively new, so some libraries and tools may still be evolving.

Use Cases

• Enterprise Applications: Line-of-business applications that benefit from code sharing and a unified technology stack.
• SPAs: Single-page applications with rich, interactive user interfaces.
• Progressive Web Apps (PWAs): Blazor WASM can be used to create PWAs that work offline and provide a native app-like experience.

Blazor WebAssembly is a powerful framework for building modern web applications using the .NET ecosystem, offering a compelling alternative to traditional JavaScript-based frameworks.

---

Blazor Server is another hosting model for Blazor applications that allows you to build rich, interactive web applications using C# and .NET. Unlike Blazor WebAssembly, which runs the .NET runtime in the browser, Blazor Server runs on the server and interacts with the client over a SignalR connection.

Key Features

• Server-Side Execution: Blazor Server applications run on the server, with the UI updates and event handling managed over a real-time SignalR connection.
• Thin Client: The client-side footprint is minimal because most of the processing happens on the server.
• Interactive UI: You can create interactive UIs using C# without needing to write JavaScript.
• Component-Based Architecture: Just like Blazor WebAssembly, Blazor Server uses reusable components written in Razor syntax.

How It Works

1. SignalR Connection: When a Blazor Server app is accessed, a SignalR connection is established between the client and the server. This connection is used to handle UI updates and user interactions in real-time.
2. Server-Side Rendering: The Blazor components are rendered on the server, and only the necessary UI changes are sent to the client over the SignalR connection.
3. Event Handling: User interactions (such as button clicks) are sent to the server, processed, and the resulting UI updates are sent back to the client.

Key Components

• Razor Components: The building blocks of a Blazor Server application, similar to Blazor WebAssembly.
• SignalR: A real-time framework used for communication between the server and the client.
• Dependency Injection: Supported out of the box for managing services and dependencies.

Development Workflow

1. Create a Blazor Server Project: Use Visual Studio or the .NET CLI to create a new Blazor Server project.
2. Build Components: Develop reusable Razor components.
3. Set Up SignalR: Configure the SignalR connection for real-time communication.
4. Implement Services: Create and register services for business logic, data access, etc.
5. Run and Debug: Use the integrated development environment (IDE) to run and debug the application.

Advantages

• Low Client-Side Requirements: Minimal client-side resources are needed since most processing is done on the server.
• SEO-Friendly: Server-side rendering allows for better search engine optimization.
• Centralized Management: Easier to manage and deploy updates since the logic resides on the server.
• Immediate Availability: No need to download and run WebAssembly; the app is available as soon as the HTML is loaded.

Limitations

• Latency: Real-time interactivity depends on the network latency and the quality of the SignalR connection.
• Scalability: Server-side processing can become a bottleneck under heavy load, requiring careful consideration of server resources and scaling strategies.
• Connection Dependency: Requires a persistent connection to the server, which might be challenging in environments with unstable internet connections.

Use Cases

• Internal Enterprise Applications: Line-of-business applications where a thin client and centralized management are beneficial.
• Admin Panels and Dashboards: Real-time updates and interactivity with server-side processing.
• Data-Driven Applications: Applications that rely heavily on server-side data processing and real-time data updates.

Comparison with Blazor WebAssembly

• Execution Model: Blazor Server runs on the server, while Blazor WebAssembly runs in the browser.
• Load Time: Blazor Server has a faster initial load time since there is no need to download the .NET runtime.
• Performance: Blazor WebAssembly provides better client-side performance for complex UI interactions as it runs directly in the browser.
• Offline Support: Blazor WebAssembly can support offline scenarios, whereas Blazor Server requires a constant connection to the server.

Blazor Server offers a compelling way to build interactive web applications with C# and .NET, leveraging server-side rendering and real-time communication to provide a rich user experience with minimal client-side overhead.

---