R3

A ReactiveProperty<T> is a specialized BehaviorSubject that holds a single value and automatically eliminates duplicate values (it won't notify if the new value is identical to the current one). It is ideal for data binding in UI contexts because its value can be updated via the .Value property.

Key behaviors:

• Update value: Use .Value = newValue to update. If the value is the same as the current one, no notification is issued.
• Force notification: If you need to notify observers even when the value is identical, call .OnNext(value) instead of setting .Value.
• Read-only access: To follow best practices (like the Android UI Layer pattern), keep a private ReactiveProperty<T> and expose it as a public ReadOnlyReactiveProperty<T>.

// Reactive Notification Model
public class Enemy
{
    public ReactiveProperty<long> CurrentHp { get; private set; }
    public ReactiveProperty<bool> IsDead { get; private set; }

    public Enemy(int initialHp)
    {
        CurrentHp = new ReactiveProperty<long>(initialHp);
        IsDead = CurrentHp.Select(x => x <= 0).ToReactiveProperty();
    }
}

// Usage
// Update value via .Value
enemy.CurrentHp.Value -= 99;

// Subscribe to changes
enemy.CurrentHp.Subscribe(x => Console.WriteLine("HP:" + x));

// Convert to read-only pattern for public APIs
class NewsViewModel
{
    ReactiveProperty<NewsUiState> _uiState = new(new NewsUiState());
    public ReadOnlyReactiveProperty<NewsUiState> UiState => _uiState;
}

You can manually manage the TimeProvider in Blazor by registering a SynchronizationContextTimeProvider as a scoped service. This approach is useful for unit testing (e.g., using bUnit), as it allows you to substitute a FakeTimeProvider easily.

// use AddScoped instead of AddBlazorR3
builder.Services.AddScoped<TimeProvider, SynchronizationContextTimeProvider>();

var app = builder.Build();

In your component:

public partial class Counter : IDisposable
{
    int currentCount = 0;
    IDisposable? subscription;

    // Inject scoped TimeProvider manually(in bUnit testing, inject FakeTimeProvider)
    [Inject]
    public required TimeProvider TimeProvider { get; init; }

    protected override void OnInitialized()
    {
        subscription = Observable.Interval(TimeSpan.FromSeconds(1), TimeProvider)
            .Subscribe(_ =>
            {
                currentCount++;
                StateHasChanged();
            });
    }

    public void Dispose()
    {
        subscription?.Dispose();
    }
}

R3 provides deep integration with async/await.

Async Methods

Methods that return a single asynchronous operation (like FirstAsync or LastAsync) return Task<T>. These transform OnErrorResume exceptions into faulted tasks.

Async Operators

You can use async functions within several operators to control execution flow. These operators accept an AwaitOperation to define how concurrent asynchronous tasks are handled.

AwaitOperation Options:

• Sequential: All values are queued; the next value waits for the current async method to complete.
• Drop: New values are dropped if an async operation is currently running.
• Switch: If a new value arrives while an async operation is running, the current one is cancelled and the new one starts.
• Parallel: All values are sent to the async method immediately (unlimited concurrency).
• SequentialParallel: All values are sent immediately, but results are queued and passed to the next operator in order.
• ThrottleFirstLast: Sends the first and last values while the async method is running.

Key Async Operators:

• SelectAwait: Transforms values using an async selector.
• WhereAwait: Filters values using an async predicate.
• SubscribeAwait: Subscribes using an async onNext handler.
• Debounce, ThrottleFirst, ThrottleLast, ThrottleFirstLast: Time-based filtering using async samplers.
• Chunk: Groups elements into chunks using an async window function.

// Example: Using AwaitOperation.Drop to prevent multiple clicks
button.OnClickAsObservable()
    .SelectAwait(async (_, ct) =>
    {
        var req = await UnityWebRequest.Get("https://google.com/").SendWebRequest().WithCancellation(ct);
        return req.downloadHandler.text;
    }, AwaitOperation.Drop)
    .SubscribeToText(text);

// Example: Using async Chunk to generate chunks at random intervals
Observable.Interval(TimeSpan.FromSeconds(1))
    .Index()
    .Chunk(async (_, ct) =>
    {
        await Task.Delay(TimeSpan.FromSeconds(Random.Shared.Next(0, 5)), ct);
    })
    .Subscribe(xs =>
    {
        Console.WriteLine(string.Join(", ", xs));
    });

To use R3 in Godot 4.x, follow these steps:

1. Install R3 from NuGet.
2. Download (or clone as a git submodule) the R3 repository.
3. Move the src/R3.Godot/addons/R3.Godot directory into your Godot project.
4. Enable the R3.Godot plugin from the Godot Plugins menu.

Godot Providers

• GodotTimeProvider.Process / GodotTimeProvider.PhysicsProcess
• GodotFrameProvider.Process / GodotFrameProvider.PhysicsProcess

An autoloaded FrameProviderDispatcher sets GodotTimeProvider.Process and GodotFrameProvider.Process as the defaults.

using Godot;
using R3;
using System;

public partial class Node2D : Godot.Node2D
{
    IDisposable subscription;

    public override void _Ready()
    {
        subscription = Observable.EveryUpdate()
            .ThrottleLastFrame(10)
            .Subscribe(x =>
            {
                GD.Print($"Observable.EveryUpdate: {GodotFrameProvider.Process.GetFrameCount()}");
            });
    }

    public override void _ExitTree()
    {
        subscription?.Dispose();
    }
}

For XAML-based platforms (like WPF), BindableReactiveProperty<T> allows you to bind observable properties to views. It implements INotifyPropertyChanged and INotifyDataErrorInfo.

To use it:

1. Expose it via new BindableReactiveProperty<T>() or convert an observable using .ToBindableReactiveProperty(initialValue).
2. In XAML, bind to the .Value property.
3. Use IReadOnlyBindableReactiveProperty<T> when read-only access is required in bindings.

public class BasicUsagesViewModel : IDisposable
{
    public BindableReactiveProperty<string> Input { get; }
    public BindableReactiveProperty<string> Output { get; }

    public BasicUsagesViewModel()
    {
        Input = new BindableReactiveProperty<string>("");
        Output = Input.Select(x => x.ToUpper()).ToBindableReactiveProperty("");
    }

    public void Dispose()
    {
        Disposable.Dispose(Input, Output);
    }
}