Expose public API for configuring DefaultExceptionHandler without builder

[glennawatson]

Context

Raised in #4296 by @ChaseFlorell. After upgrading, RxState.DefaultExceptionHandler only has a public getter — the InitializeExceptionHandler method is internal and only callable via ReactiveUIBuilder.WithExceptionHandler(). Users who have existing bootstrap pipelines (e.g., Blazor WASM, ASP.NET Core) and don't use RxAppBuilder have no way to set a custom exception handler.

Problem

// This used to work — now causes a compile error:
RxState.DefaultExceptionHandler = host.Services.GetService<IObserver<Exception>>();

The only path today is:

RxAppBuilder.CreateReactiveUIBuilder()
    .WithExceptionHandler(myHandler)
    .BuildApp();

For users with existing DI and bootstrap pipelines, this forces adoption of the full builder pattern just to set one global setting.

Proposed Solution

Add a public static method on RxState (or an extension method) that allows setting the exception handler directly:

// Option A: public setter method on RxState
RxState.SetDefaultExceptionHandler(myObserver);

// Option B: extension method on IMutableDependencyResolver
resolver.WithDefaultExceptionHandler(myObserver);

The builder's WithExceptionHandler should internally call the same public API. This keeps the builder as a convenience layer, not the only path.

Files Involved

• src/ReactiveUI/RxState.cs — make InitializeExceptionHandler public or add a public wrapper
• src/ReactiveUI/Builder/ReactiveUIBuilder.cs — call the public API internally

Acceptance Criteria

• Users can configure DefaultExceptionHandler without using RxAppBuilder
• The builder pattern continues to work as-is
• Unit tests cover both paths
• Update website documentation (see reactiveui/website issue)

Related: #4296

[glennawatson]

Closing this issue. You can configure the exception handler (and any other global state) using a lightweight builder call — you don't need to adopt the full builder for your entire app. You can also provide your own DI container:

// Minimal standalone configuration with your own container
using var locator = new ModernDependencyResolver();
locator.CreateReactiveUIBuilder()
    .WithExceptionHandler(myHandler)
    .WithCoreServices()
    .BuildApp();

For unit tests, the builder can be recreated per-test. We use ITestExecutor / BaseAppBuilderTestExecutor to manage builder lifecycle — see src/tests/ReactiveUI.Test.Utilities/AppBuilder/BaseAppBuilderTestExecutor.cs for the pattern, and AppBuilderTestHelper which saves/restores schedulers and calls RxAppBuilder.ResetForTesting() between tests. You can also use RxTest.AppBuilderTestAsync() which provides a thread-safe global test gate with timeout support.

For Blazor or ASP.NET Core apps, you can hook into your existing lifecycle events (e.g. IHostedService, Program.cs startup) and call the builder there — it's just a few lines. Thank you for raising this.

[glennawatson]

cc @ChaseFlorell — see above for how to configure exception handler and other global state without restructuring your bootstrap.

[glennawatson]

For non-TUnit frameworks, the same pattern applies using your framework's lifecycle hooks:

xUnit (use a fixture):

public class RxUIFixture : IDisposable
{
    private readonly AppBuilderTestHelper _helper = new();

    public RxUIFixture()
    {
        _helper.Initialize(builder => builder
            .WithExceptionHandler(myHandler)
            .WithCoreServices());
    }

    public void Dispose() => _helper.CleanUp();
}

public class MyTests : IClassFixture<RxUIFixture>
{
    // tests run with builder configured
}

MSTest (use [TestInitialize] / [TestCleanup]):

[TestClass]
public class MyTests
{
    private readonly AppBuilderTestHelper _helper = new();

    [TestInitialize]
    public void Setup() => _helper.Initialize(builder => builder
        .WithExceptionHandler(myHandler)
        .WithCoreServices());

    [TestCleanup]
    public void Cleanup() => _helper.CleanUp();
}

Or for async tests, use RxTest.AppBuilderTestAsync() which works with any framework.