Installation

Packages

Reference Bit.Blex for the runtime, Bit.Blex.Generators for the source generator that turns your [BlexStore] classes into reactive stores, and Bit.Blex.Blazor for the Blazor integration. The generator package ships as an analyzer only (under analyzers/dotnet/cs), so it adds nothing to your app's output. Every runtime package targets net8.0, net9.0 and net10.0.

dotnet add package Bit.Blex
dotnet add package Bit.Blex.Generators
dotnet add package Bit.Blex.Blazor

# optional, for unit tests
dotnet add package Bit.Blex.Testing

Or directly in the project file:

<ItemGroup>
  <PackageReference Include="Bit.Blex" Version="10.7.0" />
  <PackageReference Include="Bit.Blex.Generators" Version="10.7.0" PrivateAssets="all" />
  <PackageReference Include="Bit.Blex.Blazor" Version="10.7.0" />
</ItemGroup>

Register the services

AddBitBlexServices registers the manager and the middleware pipeline; AddBitBlexStore<T> registers each store as a scoped service exposed both as its concrete type and as IBlexStore. A store is attached to the manager on first resolution, so its actions are observed even in hosts without a provider component - console apps, workers and tests included.

using Bit.Blex;
using Bit.Blex.Blazor;

var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add<App>("#app");

builder.Services.AddBitBlexServices(options =>
{
    options.DevToolsName = "My App";
    options.UseMiddleware(ctx => Console.WriteLine($"[blex] {ctx.QualifiedName}"));
});

builder.Services.AddBitBlexStore<CounterStore>();
builder.Services.AddBitBlexStore<TodoStore>();

// Optional extras
builder.Services.AddBitBlexLocalStoragePersistence();
builder.Services.AddBitBlexHistory();

await builder.Build().RunAsync();

Add the provider

<BlexProvider> goes once, near the root of the app, wrapping the router. On initialization it registers every IBlexStore with the manager, restores prerendered and persisted state, and starts undo/redo recording; on first render it connects the Redux DevTools bridge.

<BlexProvider EnableDevTools="@builder.HostEnvironment.IsDevelopment()">
    <Router AppAssembly="@typeof(App).Assembly">
        <Found Context="routeData">
            <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
        </Found>
        <NotFound>
            <p>Not found.</p>
        </NotFound>
    </Router>
</BlexProvider>

Without Blazor

The core package has no JS or Blazor dependency. In a console app, worker or test, resolve the stores from DI (which registers them with the manager) and drive them directly. For persistence, implement IBlexStorage over a file or database and call AddBitBlexPersistence().

var services = new ServiceCollection();
services.AddBitBlexServices();
services.AddBitBlexStore<CounterStore>();

var provider = services.BuildServiceProvider();

// Resolving the store registers it with the manager.
var store = provider.GetRequiredService<CounterStore>();
var manager = provider.GetRequiredService<BlexManager>();

store.Increment();
Console.WriteLine(manager.CaptureGlobalState().ToJsonString());
// {"counter":{"Count":1,"Step":1}}

Trimming and AOT

Snapshots - SerializeState, persistence, the DevTools payload - go through System.Text.Json. By default that is the reflection-based serializer, whose metadata a trimmed publish (the Blazor WebAssembly release default) is free to strip for types it cannot see being used. Point the shared options at a source-generated context and every generated snapshot uses it instead.

[JsonSerializable(typeof(CartLine))]
[JsonSerializable(typeof(BlexEntityState<Todo, int>))]
internal partial class AppJsonContext : JsonSerializerContext;

// Before any store is resolved or snapshotted -- the options instance becomes
// read-only on first use, so this belongs in startup.
BlexJson.Configure(o => o.TypeInfoResolver = AppJsonContext.Default);

Requirements

• .NET 10 for Bit.Blex, Bit.Blex.Blazor and Bit.Blex.Testing.
• netstandard2.0 for the generator, as Roslyn analyzers require.
• Nullable reference types are supported and expected; generated code is annotated.