Simplifying State Management in Blazor with State Containers

What is State Container?

Think of a state container as a centralized bag where you store and manage the state of your application. It acts as a single source of truth for your data, making it easy to access and update from any part of your application. In the context of Blazor, state containers help you organize and maintain the state of your components efficiently, especially when dealing with complex interactions and data flow.

Example: Shopping Cart

Let’s consider a simple example to illustrate the need for state management. Imagine you’re building an e-commerce website using Blazor, and you want to implement a shopping cart feature. Each time a user adds an item to the cart, you need to update the cart’s state and reflect the changes across multiple components.

Without a state container, managing this scenario could become messy. You might end up passing data through multiple layers of components, leading to tightly coupled code and potential bugs. This is where a state container comes in useful and valuable.

Using a State Container in Blazor

In Blazor, you can build your own state container in minutes.

// ShoppingCartState.cs
public class ShoppingCartState
private int _itemCount = 0;
public int ItemCount => _itemCount;

public event Action OnChange;

public void AddItem()

private void NotifyStateChanged() => OnChange?.Invoke();

In this example, we’ve created a ShoppingCartState class to manage the state of our shopping cart. It contains a private field _itemCount to keep track of the number of items in the cart. We expose a read-only property ItemCount to retrieve the item count, and an AddItem() method to increment the count.
// ShoppingCart.razor
@inject ShoppingCartState ShoppingCart

Shopping Cart

: @ShoppingCart.ItemCount

@code { private void AddToCart() { ShoppingCart.AddItem(); } }

In the ShoppingCart component, we inject the ShoppingCartState service using the @inject directive. Then we use this service to display the item count and handle the “Add Item” button click event.

Implementing the state container as a singleton is a reasonable choice in this case. Here’s why:

Centralized data: Using a singleton state container ensures that all parts of the application refer to the same instance of the shopping cart, preventing inconsistencies in data.

Consistent behaviour: By ensuring that all components interact with the same instance of the shopping cart, you maintain consistent behaviour throughout the application. Users expect the same items to be in their cart regardless of which page they’re viewing, and a singleton state container helps achieve this.

Ease of access: With a singleton state container, accessing and updating the shopping cart from any component becomes straightforward. There’s no need to pass references between components or worry about synchronization issues since there’s only one instance of the shopping cart.

Scalability: While a shopping cart might seem like a small feature, it could potentially grow in complexity as additional features are added (e.g., discounts, promotions, shipping options). Using a singleton state container provides a scalable solution that can accommodate future requirements without significant architectural changes.


State containers provide a clean and efficient way to manage application state in Blazor. By centralizing your state management logic, you can simplify your code, improve maintainability, and reduce bugs. Whether you’re building a small hobby project or a large-scale enterprise application, understanding and leveraging state containers will undoubtedly level up your Blazor development skills.

Tags: , , ,