### Unity TimeProvider and FrameProvider Examples

Source: https://github.com/cysharp/r3/blob/main/README.md

Examples demonstrating the usage of R3's Unity-specific TimeProvider and FrameProvider for reactive operations within Unity's player loop.

```csharp
// ignore-timescale based interval
Observable.Interval(TimeSpan.FromSeconds(5), UnityTimeProvider.UpdateIgnoreTimeScale);

// fixed-update loop
Observable.EveryUpdate(UnityFrameProvider.FixedUpdate);

// observe PostLateUpdate
Observable.Return(42).ObserveOn(UnityFrameProvider.PostLateUpdate);
```

--------------------------------

### Basic Observable Interval Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates creating an observable that emits sequential numbers at a specified interval, filtering even numbers, and subscribing to the output. This example requires importing the R3 namespace.

```csharp
using R3;

var subscription = Observable.Interval(TimeSpan.FromSeconds(1))
    .Select((_, i) => i)
    .Where(x => x % 2 == 0)
    .Subscribe(x => Console.WriteLine($"Interval:{x}"));

var cts = new CancellationTokenSource();
```

--------------------------------

### Install R3 NuGet Package

Source: https://github.com/cysharp/r3/blob/main/README.md

Install the R3 library using the .NET CLI. This package supports various .NET versions and platforms.

```bash
dotnet add package R3
```

--------------------------------

### ObservableTracker State Examples

Source: https://github.com/cysharp/r3/blob/main/README.md

Examples of the TrackingState objects that ObservableTracker provides.

```csharp
TrackingState { TrackingId = 1, FormattedType = Timer._Timer, AddTime = 2024/01/09 4:11:39, StackTrace =...
TrackingState { TrackingId = 2, FormattedType = Where`1._Where<Unit>, AddTime = 2024/01/09 4:11:39, StackTrace =...
TrackingState { TrackingId = 3, FormattedType = Take`1._Take<Unit>, AddTime = 2024/01/09 4:11:39, StackTrace =...
```

--------------------------------

### Basic Timer Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates a simple timer that runs every 3 seconds and cancels after a key press.

```csharp
_ = Task.Run(() => { Console.ReadLine(); cts.Cancel(); });

await Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3))
    .TakeUntil(cts.Token)
    .ForEachAsync(x => Console.WriteLine($"Timer"));

subscription.Dispose();
```

--------------------------------

### R3 Range Subscription Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates subscribing to an Observable.Range in R3, which is treated as immediate execution.

```csharp
`Observable.Range(1, 10000).Subscribe()`
```

--------------------------------

### Image Asset Naming Conventions

Source: https://github.com/cysharp/r3/blob/main/sandbox/UnoSampleApp/UnoSampleApp/Assets/SharedAssets.md

Examples of how to name image assets for different scales in a shared project. Ensure the build action is set to 'Content'.

```text
\Assets\Images\logo.scale-100.png
\Assets\Images\logo.scale-200.png
\Assets\Images\logo.scale-400.png

\Assets\Images\scale-100\logo.png
\Assets\Images\scale-200\logo.png
\Assets\Images\scale-400\logo.png
```

--------------------------------

### Asynchronous Producer-Consumer Example

Source: https://github.com/cysharp/r3/blob/main/src/R3.Unity/Assets/Packages/System.Threading.Channels.8.0.0/PACKAGE.md

Demonstrates a basic producer-consumer pattern using an unbounded channel. The producer writes integers to the channel every second, and the consumer reads and prints them asynchronously. Ensure `System.Threading.Channels` is referenced.

```C#
using System;
using System.Threading.Channels;
using System.Threading.Tasks;

Channel<int> channel = Channel.CreateUnbounded<int>();

Task producer = Task.Run(async () =>
{
    int i = 0;
    while (true)
    {
        channel.Writer.TryWrite(i++);
        await Task.Delay(TimeSpan.FromSeconds(1));
    }
});

Task consumer = Task.Run(async () =>
{
    await foreach (int value in channel.Reader.ReadAllAsync())
    {
        Console.WriteLine(value);
    }
});

await Task.WhenAll(producer, consumer);
```

--------------------------------

### Install R3 Unity Package via Git URL

Source: https://github.com/cysharp/r3/blob/main/README.md

Reference the R3.Unity package using its Git URL. You can specify a version tag for stability.

```bash
https://github.com/Cysharp/R3.git?path=src/R3.Unity/Assets/R3.Unity
https://github.com/Cysharp/R3.git?path=src/R3.Unity/Assets/R3.Unity#1.0.0
```

--------------------------------

### WPF UI Property Binding Example

Source: https://github.com/cysharp/r3/blob/main/README.md

This example demonstrates binding UI element properties (Width, Height) to ViewModel properties using `Observable.EveryValueChanged` in a WPF `MainWindow`. Remember to dispose of subscriptions on window close.

```csharp
public partial class MainWindow : Window
{
    IDisposable disposable;

    public MainWindow()
    {
        InitializeComponent();

        var d1 = Observable.EveryValueChanged(this, x => x.Width).Subscribe(x => WidthText.Text = x.ToString());
        var d2 = Observable.EveryValueChanged(this, x => x.Height).Subscribe(x => HeightText.Text = x.ToString());

        disposable = Disposable.Combine(d1, d2);
    }

    protected override void OnClosed(EventArgs e)
    {
        disposable.Dispose();
    }
}
```

--------------------------------

### Take

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns a specified number of contiguous elements from the start of an observable sequence or a time duration.

```APIDOC
## Take

### Description
Returns a specified number of contiguous elements from the start of an observable sequence or a time duration.

### Method
Extension Method

### Signature
`Observable<T> Take(this Observable<T> source, Int32 count)`
`Observable<T> Take(this Observable<T> source, TimeSpan duration)`
`Observable<T> Take(this Observable<T> source, TimeSpan duration, TimeProvider timeProvider)`

### Returns
An `Observable<T>` that contains the elements taken from the start of the source sequence.
```

--------------------------------

### Reactive Notification Model Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Illustrates creating an observable model using ReactiveProperty for HP and dead status. HP changes trigger updates and conditional subscriptions.

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

    public ReactiveProperty<bool> IsDead { get; private set; }

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

// ---


// Click button, HP decrement
MyButton.OnClickAsObservable().Subscribe(_ => enemy.CurrentHp.Value -= 99);

// subscribe from notification model.
enemy.CurrentHp.Subscribe(x => Console.WriteLine("HP:" + x));
enemy.IsDead.Where(isDead => isDead == true)
    .Subscribe(_ =>
    {
        // when dead, disable button
        MyButton.SetDisable();
    });
```

--------------------------------

### Immediate Emission Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates how Observable.Range can emit values immediately, making it difficult to stop the stream even after disposal. This behavior is due to the nature of immediate value emission.

```csharp
Observable.Range(0, int.MaxValue)
    .Do(onNext: x => Console.WriteLine($"Do:{x}"))
    .Take(10)
    .Subscribe(x => Console.WriteLine($"Subscribe:{x}"));
```

--------------------------------

### MAUI Default Exception Handler Implementation

Source: https://github.com/cysharp/r3/blob/main/README.md

Example implementation of `R3MauiDefaultExceptionHandler` for MAUI, which logs unhandled exceptions using `System.Diagnostics.Trace` and `ILogger`.

```csharp
public class R3MauiDefaultExceptionHandler(IServiceProvider serviceProvider) : IR3MauiExceptionHandler
{
    public void HandleException(Exception ex)
    {
        System.Diagnostics.Trace.TraceError("R3 Unhandled Exception {0}", ex);

        var logger = serviceProvider.GetService<ILogger<R3MauiDefaultExceptionHandler>>();
        logger?.LogError(ex, "R3 Unhandled Exception");
    }
}
```

--------------------------------

### ReactiveCommand Example in WPF

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates the usage of ReactiveCommand within a WPF ViewModel and its binding in XAML. The command is triggered by a CheckBox's state.

```csharp
public class CommandViewModel : IDisposable
{
    public BindableReactiveProperty<bool> OnCheck { get; } // bind to CheckBox
    public ReactiveCommand ShowMessageBox { get; }   // bind to Button, non generics ReactiveCommand is ReactiveCommand<Unit>

    public CommandViewModel()
    {
        OnCheck = new BindableReactiveProperty<bool>();
        ShowMessageBox = OnCheck.ToReactiveCommand(_ =>
        {
            MessageBox.Show("clicked");
        });
    }

    public void Dispose()
    {
        Disposable.Dispose(OnCheck, ShowMessageBox);
    }
}
```

```xml
<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <local:CommandViewModel />
    </Window.DataContext>
    <StackPanel Margin="10">
        <Label Content="Command" />
        <CheckBox IsChecked="{Binding OnCheck.Value}" />
        <Button Content="Btn" Command="{Binding ShowMessageBox}" />
    </StackPanel>
</Window>
```

--------------------------------

### Index (Unit)

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns an observable sequence of integers that are indexed sequentially starting from zero.

```APIDOC
## Index (Unit)

### Description
Returns an observable sequence of integers that are indexed sequentially starting from zero. This overload is used when the source observable emits `Unit`.

### Method
`Observable<Int32> Index(this Observable<Unit> source)`

### Parameters
- **source** (`Observable<Unit>`): The source observable sequence emitting `Unit`.
```

--------------------------------

### WithLatestFrom Operator Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Combines the latest values from two observable sequences using a result selector function.

```csharp
first.WithLatestFrom(second, (f, s) => ResultSelector(f, s))
```

--------------------------------

### Take

Source: https://github.com/cysharp/r3/blob/main/README.md

Returns a specified number of contiguous elements from the start of an observable sequence. Overloads are provided to take elements based on a count or a duration.

```APIDOC
## Take

### Description
Returns a specified number of contiguous elements from the start of an observable sequence, or elements within a specified duration.

### Method
Extension Method

### Parameters
- **source** (`Observable<T>`) - The source observable sequence.
- **count** (`Int32`) - The number of elements to take.
- **duration** (`TimeSpan`) - The time duration for which to take elements.
- **timeProvider** (`TimeProvider`) - Optional. The time provider to use for duration-based taking.

### Returns
`Observable<T>` - An observable sequence that contains the elements taken from the start of the source sequence.
```

--------------------------------

### WhereAwait Operator Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Filters an observable sequence based on an asynchronous predicate. Supports sequential or concurrent execution and cancellation options.

```csharp
source.WhereAwait(async (x, ct) => await SomeAsync(x, ct), awaitOperation: AwaitOperation.Sequential)
```

--------------------------------

### TakeFrame

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns a specified number of contiguous frames from the start of an observable sequence.

```APIDOC
## TakeFrame

### Description
Returns a specified number of contiguous frames from the start of an observable sequence.

### Method
Extension Method

### Signature
`Observable<T> TakeFrame(this Observable<T> source, Int32 frameCount)`
`Observable<T> TakeFrame(this Observable<T> source, Int32 frameCount, FrameProvider frameProvider)`

### Returns
An `Observable<T>` that contains the frames taken from the start of the source sequence.
```

--------------------------------

### Initialize Avalonia RenderingFrameProvider

Source: https://github.com/cysharp/r3/blob/main/README.md

Instantiate `AvaloniaRenderingFrameProvider` with the `TopLevel` of your Avalonia window. This provider synchronizes frame-based operations with the rendering loop.

```csharp
public partial class MainWindow : Window
{
    AvaloniaRenderingFrameProvider frameProvider;

    public MainWindow()
    {
        InitializeComponent();

        // initialize RenderingFrameProvider
        var topLevel = TopLevel.GetTopLevel(this);
        this.frameProvider = new AvaloniaRenderingFrameProvider(topLevel!);
    }

    protected override void OnLoaded(RoutedEventArgs e)
    {
        // pass frameProvider
        Observable.EveryValueChanged(this, x => x.Width, frameProvider)
            .Subscribe(x => textBlock.Text = x.ToString());
    }

    protected override void OnClosed(EventArgs e)
    {
        frameProvider.Dispose();
    }
}
```

--------------------------------

### WhereNotNull Operator Example

Source: https://github.com/cysharp/r3/blob/main/README.md

Filters out null values from an observable sequence of nullable types.

```csharp
source.WhereNotNull()
```

--------------------------------

### Default R3 Provider Initialization for Unity

Source: https://github.com/cysharp/r3/blob/main/README.md

Sets up the default observable system for R3 in Unity, including registering an unhandled exception handler and setting default time and frame providers.

```csharp
public static class UnityProviderInitializer
{
    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
    public static void SetDefaultObservableSystem()
    {
        SetDefaultObservableSystem(static ex => UnityEngine.Debug.LogException(ex));
    }

    public static void SetDefaultObservableSystem(Action<Exception> unhandledExceptionHandler)
    {
        ObservableSystem.RegisterUnhandledExceptionHandler(unhandledExceptionHandler);
        ObservableSystem.DefaultTimeProvider = UnityTimeProvider.Update;
        ObservableSystem.DefaultFrameProvider = UnityFrameProvider.Update;
    }
}
```

--------------------------------

### Combining Disposables with CreateBuilder

Source: https://github.com/cysharp/r3/blob/main/README.md

Shows how to use `Disposable.CreateBuilder` when the number of subscriptions is not statically known or is large. The builder itself is a struct, avoiding allocations.

```csharp
public partial class MainWindow : Window
{
    IDisposable disposable;

    public MainWindow()
    {
        var d = Disposable.CreateBuilder();
        Observable.IntervalFrame(1).Subscribe().AddTo(ref d);
        Observable.IntervalFrame(1).Subscribe().AddTo(ref d);
        Observable.IntervalFrame(1).Subscribe().AddTo(ref d);

        disposable = d.Build();
    }

    protected override void OnClosed(EventArgs e)
    {
        disposable.Dispose();
    }
}
```

--------------------------------

### Accessing Raw Assets at Runtime

Source: https://github.com/cysharp/r3/blob/main/sandbox/MauiApp1/Resources/Raw/AboutAssets.txt

This C# code demonstrates how to load and read the contents of a raw asset file deployed with your application using FileSystem.OpenAppPackageFileAsync.

```csharp
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Using TimeProvider for Time Abstraction

Source: https://github.com/cysharp/r3/blob/main/src/R3.Unity/Assets/Packages/Microsoft.Bcl.TimeProvider.8.0.0/PACKAGE.md

Demonstrates how to use TimeProvider to abstract time-related operations. Inject TimeProvider into classes to enable easier testing and control over time.

```csharp
using System;

// A class that uses TimeProvider to get the current time in Utc coordinates
public class UtcClock
{
    private readonly TimeProvider _timeProvider;

    // Constructor that takes a TimeProvider as a dependency
    public Clock(TimeProvider timeProvider)
    {
        _timeProvider = timeProvider;
    }

    // A method that returns the current time as a string
    public string GetTime()
    {
        return _timeProvider.GetLocalNow().ToString("HH:mm:ss");
    }
}

// A class that inherits from TimeProvider and overrides the GetLocalNow method
public class UtcTimeProvider : TimeProvider
{
    // Override the GetLocalNow method to always return UTC time
    public override DateTimeOffset GetLocalNow()
    {
        return TimeProvider.System.GetUtcNow();
    }
}

```

--------------------------------

### MauiAsset Build Action in .csproj

Source: https://github.com/cysharp/r3/blob/main/sandbox/MauiApp1/Resources/Raw/AboutAssets.txt

This XML snippet shows how to configure the MauiAsset build action in your .csproj file to include all files in the Resources\Raw directory and its subdirectories.

```xml
<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
```

--------------------------------

### Accessing Android Assets

Source: https://github.com/cysharp/r3/blob/main/sandbox/UnoSampleApp/UnoSampleApp/Platforms/Android/Assets/AboutAssets.txt

Demonstrates how to open an asset file from the Android Assets folder using the AssetManager in an Uno Platform Activity.

```csharp
public class ReadAsset : Activity
{
	protected override void OnCreate (Bundle bundle)
	{
		base.OnCreate (bundle);

		InputStream input = Assets.Open ("my_asset.txt");
	}
}
```

--------------------------------

### Basic ReactiveProperty in C#

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates the basic structure of a ReactiveProperty in C# for managing UI state, similar to Kotlin's MutableStateFlow.

```csharp
class NewsViewModel
{
    ReactiveProperty<NewsUiState> _uiState = new(new NewsUiState());
    public ReadOnlyReactiveProperty<NewsUiState> UiState => _uiState;
}
```

--------------------------------

### ViewModel with ReadOnlyReactiveProperty

Source: https://github.com/cysharp/r3/blob/main/README.md

Example of a ViewModel using ReadOnlyReactiveProperty, following Android UI Layer guidance. This pattern is effective for data binding in UI contexts.

```kotlin
class NewsViewModel(...) : ViewModel() {

```

--------------------------------

### Basic R3 Usage in Godot Node

Source: https://github.com/cysharp/r3/blob/main/README.md

Minimal sample demonstrating R3 usage within a Godot Node. Subscribes to Observable.EveryUpdate and disposes on exit.

```csharp
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();
    }
}
```

--------------------------------

### Select

Source: https://github.com/cysharp/r3/blob/main/README.md

Projects each element of an observable sequence into a new form.

```APIDOC
## Select

### Description
Projects each element of an observable sequence into a new form by applying a selector function. This allows transforming the elements of the sequence.

### Method
`Observable<TResult> Select(this Observable<T> source, Func<T, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, Func<T, Int32, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, TState, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, Int32, TState, TResult> selector)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Observable<TResult>** - An observable sequence that contains elements projected into the new form.
```

--------------------------------

### Subscription Management with AddTo in Unity

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates how to manage Rx subscriptions within the Unity component lifecycle using `AddTo`. The `AddTo` method ensures subscriptions are disposed of when the component is destroyed, preventing memory leaks. Use `ref d` for better performance and `RegisterTo` with `destroyCancellationToken` for robust cancellation.

```csharp
// simple pattern
Observable.EveryUpdate().Subscribe().AddTo(this);
Observable.EveryUpdate().Subscribe().AddTo(this);
Observable.EveryUpdate().Subscribe().AddTo(this);

// better performance
var d = Disposable.CreateBuilder();
Observable.EveryUpdate().Subscribe().AddTo(ref d);
Observable.EveryUpdate().Subscribe().AddTo(ref d);
Observable.EveryUpdate().Subscribe().AddTo(ref d);
d.RegisterTo(this.destroyCancellationToken); // Build and Register
```

--------------------------------

### Initialize WinUI3 Observable System

Source: https://github.com/cysharp/r3/blob/main/README.md

Call WinUI3ProviderInitializer.SetDefaultObservableSystem() during application startup to replace the default time and frame providers with WinUI3-specific ones. Ensure an UnhandledExceptionHandler is set.

```csharp
public partial class App : Application
{
    public App()
    {
        this.InitializeComponent();

        // Add this line.
        // You need to set UnhandledExceptionHandler
        WinUI3ProviderInitializer.SetDefaultObservableSystem(ex => Trace.WriteLine(ex.ToString()));
    }

    // OnLaunched...
}
```

--------------------------------

### Avalonia Unhandled Exception Handler

Source: https://github.com/cysharp/r3/blob/main/README.md

Register a custom handler for R3 unhandled exceptions in your Avalonia application using `ObservableSystem.RegisterUnhandledExceptionHandler`. This example logs errors using a provided `Logger.Sink`.

```csharp
ex => Logger.Sink?.Log(LogEventLevel.Error, "R3", null, "R3 Unhandled Exception {0}", ex);
```

--------------------------------

### Thread Safety Issue with dotnet/reactive Subject

Source: https://github.com/cysharp/r3/blob/main/README.md

Illustrates a common thread safety issue in dotnet/reactive where a Subject is accessed by multiple threads, leading to incorrect results. This example shows that operators are not thread-safe.

```csharp
// dotnet/reactive
var subject = new System.Reactive.Subjects.Subject<int>();

// single execution shows 100 but actually 9* multiple times(broken)
subject.Take(100).Count().Subscribe(x => Console.WriteLine(x));

Parallel.For(0, 1000, new ParallelOptions { MaxDegreeOfParallelism = 10 }, x => subject.OnNext(x));
```

--------------------------------

### ReplayFrame

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns a 

### Method
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 window)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 window, FrameProvider frameProvider)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 bufferSize, Int32 window)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 bufferSize, Int32 window, FrameProvider frameProvider)`

```APIDOC
## ReplayFrame

### Description
Returns a 

### Method
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 window)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 window, FrameProvider frameProvider)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 bufferSize, Int32 window)`
`ConnectableObservable<T> ReplayFrame(this Observable<T> source, Int32 bufferSize, Int32 window, FrameProvider frameProvider)`
```

--------------------------------

### Preventing Multiple Clicks with Drop Operation

Source: https://github.com/cysharp/r3/blob/main/README.md

Use the `AwaitOperation.Drop` strategy to prevent multiple rapid asynchronous operations, such as handling button clicks. This example shows how to fetch web content only when the button is clicked and the previous request is not in progress.

```csharp
// for example...
// Drop enables prevention of execution by 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);
```

--------------------------------

### Combining Disposables with Combine Method

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates using `Disposable.Combine` to bundle multiple IDisposables, offering the best performance when the number of subscriptions is statically determined, especially for 8 or fewer arguments.

```csharp
public partial class MainWindow : Window
{
    IDisposable disposable;

    public MainWindow()
    {
        var d1 = Observable.IntervalFrame(1).Subscribe();
        var d2 = Observable.IntervalFrame(1).Subscribe();
        var d3 = Observable.IntervalFrame(1).Subscribe();

        disposable = Disposable.Combine(d1, d2, d3);
    }

    protected override void OnClosed(EventArgs e)
    {
        disposable.Dispose();
    }
}
```

--------------------------------

### Basic BindableReactiveProperty ViewModel

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates a ViewModel with input and output properties using BindableReactiveProperty. The output is derived from the input, converted to uppercase.

```csharp
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);
    }
}
```

--------------------------------

### Loading Font Assets

Source: https://github.com/cysharp/r3/blob/main/sandbox/UnoSampleApp/UnoSampleApp/Platforms/Android/Assets/AboutAssets.txt

Shows how to load a font file from the Android Assets folder using Typeface.CreateFromAsset.

```csharp
Typeface tf = Typeface.CreateFromAsset (Context.Assets, "fonts/samplefont.ttf");
```

--------------------------------

### Do

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Performs an action for each event in the observable sequence.

```APIDOC
## Do

### Description
Performs an action for each event in the observable sequence, including onNext, onErrorResume, onCompleted, onDispose, and onSubscribe. Overloads allow passing state.

### Method
Extension Method

### Parameters
#### Path Parameters
- **source** (Observable<T>) - The source observable sequence.
- **onNext** (Action<T>) - Optional. Action to execute on each element.
- **onErrorResume** (Action<Exception>) - Optional. Action to execute on error.
- **onCompleted** (Action<Result>) - Optional. Action to execute on completion.
- **onDispose** (Action) - Optional. Action to execute on dispose.
- **onSubscribe** (Action) - Optional. Action to execute on subscribe.
- **state** (TState) - Optional. State to pass to the actions.

### Response
#### Success Response
- Observable<T>: The source observable sequence, with the side effects of the actions.
```

--------------------------------

### Initialize R3 WPF Providers

Source: https://github.com/cysharp/r3/blob/main/README.md

Call `SetDefaultObservableSystem` in your WPF application's startup to replace default time and frame providers with WPF-specific ones. Ensure to set an unhandled exception handler.

```csharp
public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        // You need to set UnhandledExceptionHandler
        WpfProviderInitializer.SetDefaultObservableSystem(ex => Trace.WriteLine($"R3 UnhandledException:{ex}"));
    }
}
```

--------------------------------

### Async Retry with UnityWebRequest

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates how to use async/await with Retry for handling UnityWebRequest operations. It retries up to 3 times on failure.

```csharp
button.OnClickAsObservable()
    .SelectAwait(async (_, ct) =>
    {
        var retry = 0;
    AGAIN:
        try
        {
            var req = await UnityWebRequest.Get("https://google.com/").SendWebRequest().WithCancellation(ct);
            return req.downloadHandler.text;
        }
        catch
        {
            if (retry++ < 3) goto AGAIN;
            throw;
        }
    }, AwaitOperation.Drop)
```

--------------------------------

### Factory Methods

Source: https://github.com/cysharp/r3/blob/main/README.md

This section lists the factory methods available for creating Observables. Each method is described with its parameters and return type.

```APIDOC
## Factory Methods

This section lists the factory methods available for creating Observables. Each method is described with its parameters and return type.

### Never()

**Description**: Creates an Observable that never calls OnNext or OnCompleted.

### NextFrame(CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit when the next frame starts.

### NextFrame(FrameProvider frameProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit when the next frame starts, using a specific FrameProvider.

### ObservePropertyChanged<T, TProperty>(this T value, Func<T, TProperty> propertySelector, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String expr = default)

**Description**: Observes property changes on an object. Emits the property's value when it changes.

### ObservePropertyChanged<T, TProperty1, TProperty2>(this T value, Func<T, TProperty1> propertySelector1, Func<TProperty1, TProperty2> propertySelector2, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String propertySelector1Expr = default, String propertySelector2Expr = default)

**Description**: Observes changes in a chain of two properties on an object. Emits the final property's value when it changes.

### ObservePropertyChanged<T, TProperty1, TProperty2, TProperty3>(this T value, Func<T, TProperty1> propertySelector1, Func<TProperty1, TProperty2> propertySelector2, Func<TProperty2, TProperty3> propertySelector3, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String propertySelector1Expr = default, String propertySelector2Expr = default, String propertySelector3Expr = default)

**Description**: Observes changes in a chain of three properties on an object. Emits the final property's value when it changes.

### ObservePropertyChanging<T, TProperty>(this T value, Func<T, TProperty> propertySelector, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String expr = default)

**Description**: Observes property changes before they occur on an object. Emits the property's value before it changes.

### ObservePropertyChanging<T, TProperty1, TProperty2>(this T value, Func<T, TProperty1> propertySelector1, Func<TProperty1, TProperty2> propertySelector2, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String propertySelector1Expr = default, String propertySelector2Expr = default)

**Description**: Observes changes in a chain of two properties before they occur on an object. Emits the final property's value before it changes.

### ObservePropertyChanging<T, TProperty1, TProperty2, TProperty3>(this T value, Func<T, TProperty1> propertySelector1, Func<TProperty1, TProperty2> propertySelector2, Func<TProperty2, TProperty3> propertySelector3, Boolean pushCurrentValueOnSubscribe = true, CancellationToken cancellationToken = default, String propertySelector1Expr = default, String propertySelector2Expr = default, String propertySelector3Expr = default)

**Description**: Observes changes in a chain of three properties before they occur on an object. Emits the final property's value before it changes.

### Race<T>(params Observable<T>[] sources)

**Description**: Creates an Observable that subscribes to all sources and forwards all emitted values from the first source to emit.

### Race<T>(IEnumerable<Observable<T>> sources)

**Description**: Creates an Observable that subscribes to all sources and forwards all emitted values from the first source to emit.

### Range(Int32 start, Int32 count)

**Description**: Creates an Observable that emits a sequence of integral numbers within a specified range.

### Range(Int32 start, Int32 count, CancellationToken cancellationToken)

**Description**: Creates an Observable that emits a sequence of integral numbers within a specified range, with cancellation support.

### Repeat<T>(T value, Int32 count)

**Description**: Creates an Observable that repeats a given value a specified number of times.

### Repeat<T>(T value, Int32 count, CancellationToken cancellationToken)

**Description**: Creates an Observable that repeats a given value a specified number of times, with cancellation support.

### Return<T>(T value)

**Description**: Creates an Observable that emits a single value and then completes.

### Return<T>(T value, TimeProvider timeProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a single value after a delay, using a specific TimeProvider and cancellation support.

### Return<T>(T value, TimeSpan dueTime, TimeProvider timeProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a single value after a specified delay, using a specific TimeProvider and cancellation support.

### Return<T>(Unit value)

**Description**: Creates an Observable that emits a single Unit value and then completes.

### Return<T>(Boolean value)

**Description**: Creates an Observable that emits a single Boolean value and then completes.

### Return<T>(Int32 value)

**Description**: Creates an Observable that emits a single Int32 value and then completes.

### ReturnFrame<T>(T value, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a value on the next frame.

### ReturnFrame<T>(T value, FrameProvider frameProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a value on the next frame, using a specific FrameProvider.

### ReturnFrame<T>(T value, Int32 dueTimeFrame, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a value after a specified number of frames.

### ReturnFrame<T>(T value, Int32 dueTimeFrame, FrameProvider frameProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a value after a specified number of frames, using a specific FrameProvider.

### ReturnOnCompleted<T>(Result result)

**Description**: Creates an Observable that completes immediately with a given result.

### ReturnOnCompleted<T>(Result result, TimeProvider timeProvider)

**Description**: Creates an Observable that completes immediately with a given result, using a specific TimeProvider.

### ReturnOnCompleted<T>(Result result, TimeSpan dueTime, TimeProvider timeProvider)

**Description**: Creates an Observable that completes after a delay with a given result, using a specific TimeProvider.

### ReturnUnit()

**Description**: Creates an Observable that emits a single Unit value and then completes.

### Throw<T>(Exception exception)

**Description**: Creates an Observable that immediately calls OnError with the given exception.

### Throw<T>(Exception exception, TimeProvider timeProvider)

**Description**: Creates an Observable that immediately calls OnError with the given exception, using a specific TimeProvider.

### Throw<T>(Exception exception, TimeSpan dueTime, TimeProvider timeProvider)

**Description**: Creates an Observable that calls OnError after a delay with the given exception, using a specific TimeProvider.

### Timer(TimeSpan dueTime, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit after a specified delay.

### Timer(DateTimeOffset dueTime, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit at a specified time.

### Timer(TimeSpan dueTime, TimeSpan period, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit after a specified delay, and then periodically at a specified interval.

### Timer(DateTimeOffset dueTime, TimeSpan period, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit at a specified time, and then periodically at a specified interval.

### Timer(TimeSpan dueTime, TimeProvider timeProvider, CancellationToken cancellationToken = default)

**Description**: Creates an Observable that emits a Unit after a specified delay, using a specific TimeProvider and cancellation support.

```

--------------------------------

### Select

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Projects each element of an observable sequence into a new form. 

### Method
`Observable<TResult> Select(this Observable<T> source, Func<T, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, Func<T, Int32, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, TState, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, Int32, TState, TResult> selector)`

```APIDOC
## Select

### Description
Projects each element of an observable sequence into a new form. 

### Method
`Observable<TResult> Select(this Observable<T> source, Func<T, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, Func<T, Int32, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, TState, TResult> selector)`
`Observable<TResult> Select(this Observable<T> source, TState state, Func<T, Int32, TState, TResult> selector)`
```

--------------------------------

### Replay

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns a 

### Method
`ConnectableObservable<T> Replay(this Observable<T> source)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize)`
`ConnectableObservable<T> Replay(this Observable<T> source, TimeSpan window)`
`ConnectableObservable<T> Replay(this Observable<T> source, TimeSpan window, TimeProvider timeProvider)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize, TimeSpan window)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize, TimeSpan window, TimeProvider timeProvider)`

```APIDOC
## Replay

### Description
Returns a 

### Method
`ConnectableObservable<T> Replay(this Observable<T> source)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize)`
`ConnectableObservable<T> Replay(this Observable<T> source, TimeSpan window)`
`ConnectableObservable<T> Replay(this Observable<T> source, TimeSpan window, TimeProvider timeProvider)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize, TimeSpan window)`
`ConnectableObservable<T> Replay(this Observable<T> source, Int32 bufferSize, TimeSpan window, TimeProvider timeProvider)`
```

--------------------------------

### Create Observable from Event using FromEvent

Source: https://github.com/cysharp/r3/blob/main/README.md

Demonstrates how to convert an existing event into an Observable using Observable.FromEvent. This requires handling delegate conversion and event subscription/unsubscription.

```csharp
Observable.FromEvent<RoutedEventHandler, RoutedEventArgs>(
    h => (sender, e) => h(e),
    e => button.Click += e,
    e => button.Click -= e);
```

--------------------------------

### Configure R3 for Uno Applications

Source: https://github.com/cysharp/r3/blob/main/README.md

Call `UseR3()` in `ApplicationBuilder` to set default Uno time and frame providers. This allows time-based operations to use `DispatcherTimer` for UI reflection.

```csharp
public partial class App : Application
{
    protected async override void OnLaunched(LaunchActivatedEventArgs args)
    {
        var builder = this.CreateBuilder(args)
            .UseR3() // add this line
            ...
    }
}
```

--------------------------------

### Publish

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Returns a 

### Method
`ConnectableObservable<T> Publish(this Observable<T> source)`
`ConnectableObservable<T> Publish(this Observable<T> source, T initialValue)`

```APIDOC
## Publish

### Description
Returns a 

### Method
`ConnectableObservable<T> Publish(this Observable<T> source)`
`ConnectableObservable<T> Publish(this Observable<T> source, T initialValue)`
```

--------------------------------

### Unit Test FrameProvider with LiveList

Source: https://github.com/cysharp/r3/blob/main/README.md

Test frame-based observables using FakeFrameProvider and LiveList to assert frame counts and completion status.

```csharp
var cts = new CancellationTokenSource();
var frameProvider = new FakeFrameProvider();

var list = Observable.EveryUpdate(frameProvider, cts.Token)
    .Select(_ => frameProvider.GetFrameCount())
    .ToLiveList();

list.AssertEqual([]); // list.ShouldBe(expected);

frameProvider.Advance();
list.AssertEqual([0]);

frameProvider.Advance(3);
list.AssertEqual([0, 1, 2, 3]);

cts.Cancel();
list.AssertIsCompleted(); // list.IsCompleted.ShouldBeTrue();

frameProvider.Advance();
list.AssertEqual([0, 1, 2, 3]);
list.AssertIsCompleted();
```

--------------------------------

### Configure R3 for MAUI Applications

Source: https://github.com/cysharp/r3/blob/main/README.md

Use `UseR3()` in `MauiAppBuilder` to configure MAUI-specific time and frame providers. This enables time-based operations with `IDispatcher` and frame-based operations with `Ticker`.

```csharp
public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        })
        .UseR3(); // add this line

    return builder.Build();
}
```

--------------------------------

### SelectAwait

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Projects each element of an observable sequence to an asynchronous operation. 

### Method
`Observable<TResult> SelectAwait(this Observable<T> source, Func<T, CancellationToken, ValueTask<TResult>> selector, AwaitOperation awaitOperation = AwaitOperation.Sequential, Boolean configureAwait = true, Boolean cancelOnCompleted = false, Int32 maxConcurrent = -1)`

```APIDOC
## SelectAwait

### Description
Projects each element of an observable sequence to an asynchronous operation. 

### Method
`Observable<TResult> SelectAwait(this Observable<T> source, Func<T, CancellationToken, ValueTask<TResult>> selector, AwaitOperation awaitOperation = AwaitOperation.Sequential, Boolean configureAwait = true, Boolean cancelOnCompleted = false, Int32 maxConcurrent = -1)`
```

--------------------------------

### Unit Test Timer with LiveList and FakeTimeProvider

Source: https://github.com/cysharp/r3/blob/main/README.md

Test timer-based observables by advancing FakeTimeProvider and asserting LiveList states for completion and emitted values.

```csharp
var fakeTime = new FakeTimeProvider();

var list = Observable.Timer(TimeSpan.FromSeconds(5), fakeTime).ToLiveList();

fakeTime.Advance(TimeSpan.FromSeconds(4));
list.AssertIsNotCompleted();

fakeTime.Advance(TimeSpan.FromSeconds(1));
list.AssertIsCompleted();
list.AssertEqual([Unit.Default]);
```

--------------------------------

### MonoGame Initialization with ObservableSystemComponent

Source: https://github.com/cysharp/r3/blob/main/README.md

Initializes R3 extensions for MonoGame by adding an ObservableSystemComponent to the game. This component sets up time and frame providers and configures the unhandled exception handler.

```csharp
public class Game1 : Game
{
    public Game1()
    {
        var observableSystemComponent = new ObservableSystemComponent(this);
        Components.Add(observableSystemComponent);
    }
}
```

--------------------------------

### Prepend

Source: https://github.com/cysharp/r3/blob/main/docs/reference_operator.md

Prepends 

### Method
`Observable<T> Prepend(this Observable<T> source, T value)`
`Observable<T> Prepend(this Observable<T> source, IEnumerable<T> values)`
`Observable<T> Prepend(this Observable<T> source, Func<T> valueFactory)`
`Observable<T> Prepend(this Observable<T> source, TState state, Func<TState, T> valueFactory)`

```APIDOC
## Prepend

### Description
Prepends 

### Method
`Observable<T> Prepend(this Observable<T> source, T value)`
`Observable<T> Prepend(this Observable<T> source, IEnumerable<T> values)`
`Observable<T> Prepend(this Observable<T> source, Func<T> valueFactory)`
`Observable<T> Prepend(this Observable<T> source, TState state, Func<TState, T> valueFactory)`
```

--------------------------------

### CreateFrom

Source: https://github.com/cysharp/r3/blob/main/docs/reference_factory.md

Creates an Observable from an asynchronous enumerable factory.

```APIDOC
## CreateFrom

### Description
Creates an Observable from an asynchronous enumerable factory.

### Method
N/A (Factory Method)

### Endpoint
N/A (Factory Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
- **Observable<T>** - An Observable that emits items from the asynchronous enumerable.

#### Response Example
None
```

--------------------------------

### Observer Shortcut for Result Completion

Source: https://github.com/cysharp/r3/blob/main/README.md

Use observer's OnCompleted shortcuts to signal success or failure with a Result, simplifying Result generation.

```csharp
observer.OnCompleted(Result.Success);
observer.OnCompleted(Result.Failure(exception));

observer.OnCompleted(); // same as Result.Success
observer.OnCompleted(exception); // same as Result.Failure(exception)
```

--------------------------------

### Convert Godot Signals to Observables (2-9 arguments)

Source: https://github.com/cysharp/r3/blob/main/README.md

These extension methods allow you to convert Godot signals into Rx.NET Observables. Use these when you need to react to signals in a reactive programming style. Ensure the `[MustBeVariant]` attribute is used for generic type parameters.

```csharp
public static Observable<(T0, T1)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3, T4)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3, [MustBeVariant] T4>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3, T4, T5)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3, [MustBeVariant] T4, [MustBeVariant] T5>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3, T4, T5, T6)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3, [MustBeVariant] T4, [MustBeVariant] T5, [MustBeVariant] T6>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3, T4, T5, T6, T7)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3, [MustBeVariant] T4, [MustBeVariant] T5, [MustBeVariant] T6, [MustBeVariant] T7>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
public static Observable<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> SignalAsObservable<[MustBeVariant] T0, [MustBeVariant] T1, [MustBeVariant] T2, [MustBeVariant] T3, [MustBeVariant] T4, [MustBeVariant] T5, [MustBeVariant] T6, [MustBeVariant] T7, [MustBeVariant] T8>(this GodotObject obj, StringName signalName, CancellationToken cancellationToken = default)
```

--------------------------------

### Custom MAUI Exception Handler with Callback

Source: https://github.com/cysharp/r3/blob/main/README.md

Provide a callback to `UseR3` to customize the unhandled exception handling in MAUI. This allows for simple, inline exception logging.

```csharp
builder.UseR3(ex => Console.WriteLine($"R3 UnhandledException:{ex}"));
```

--------------------------------

### Configure R3 for WinForms Applications

Source: https://github.com/cysharp/r3/blob/main/README.md

Call `WinFormsProviderInitializer.SetDefaultObservableSystem()` in `Program.Main` to set default WinForms time and frame providers. This ensures timers operate on the correct thread.

```csharp
using R3.WinForms;

internal static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();

        var form = new Form1();

        // add this line
        WinFormsProviderInitializer.SetDefaultObservableSystem(ex => Trace.WriteLine($"R3 UnhandledException:{ex}"), form);

        Application.Run(form);
    }
}
```

--------------------------------

### Configure Default Time and Frame Providers

Source: https://github.com/cysharp/r3/blob/main/README.md

Set the default TimeProvider and FrameProvider for ObservableSystem. This allows customization for different environments like WPF.

```csharp
public static class ObservableSystem
{
    public static TimeProvider DefaultTimeProvider { get; set; } = TimeProvider.System;
    public static FrameProvider DefaultFrameProvider { get; set; } = new NotSupportedFrameProvider();

    static Action<Exception> unhandledException = DefaultUnhandledExceptionHandler;

    // Prevent +=, use Set and Get method.
    public static void RegisterUnhandledExceptionHandler(Action<Exception> unhandledExceptionHandler)
    {
        unhandledException = unhandledExceptionHandler;
    }

    public static Action<Exception> GetUnhandledExceptionHandler()
    {
        return unhandledException;
    }

    static void DefaultUnhandledExceptionHandler(Exception exception)
    {
        Console.WriteLine("R3 UnhandledException: " + exception.ToString());
    }
}
```