ReactiveUI Documentation

To migrate existing code to use RxSchedulers and remove attribute requirements:

1. Replace RxApp.MainThreadScheduler with RxSchedulers.MainThreadScheduler.
2. Replace RxApp.TaskpoolScheduler with RxSchedulers.TaskpoolScheduler.
3. Remove RequiresUnreferencedCode and RequiresDynamicCode attributes if they were only needed for scheduler access.
4. Use ReactiveProperty<T>.Create() factory methods instead of constructors.
5. Test that unit tests still work (you may need to manually set test schedulers if you relied on automatic detection).

ReactiveUI provides platform-specific packages to ensure proper performance and integration. You must install the core package along with the package corresponding to your target platform.

Core and Utility Packages:

• .NET Standard: ReactiveUI
• Any: ReactiveUI.SourceGenerators (for boilerplate reduction)
• Any: ReactiveUI.Validation (for user input validation)
• Any: ReactiveUI.Extensions
• Unit Testing: ReactiveUI.Testing

Platform-Specific Packages:

• WPF: ReactiveUI.WPF
• WinUI: ReactiveUI.WinUI
• MAUI: ReactiveUI.Maui
• Windows Forms: ReactiveUI.WinForms
• AndroidX: ReactiveUI.AndroidX
• Blazor: ReactiveUI.Blazor
• Uno Platform: ReactiveUI.Uno or ReactiveUI.Uno.WinUI
• Avalonia: ReactiveUI.Avalonia

ReactiveUI is an OSI-approved open source project. If you wish to contribute:

1. Discuss first: Open a GitHub issue to discuss your proposed changes before submitting a Pull Request.
2. Follow guidelines: Refer to the Contribution Guidelines for detailed instructions. The project is friendly to first-time PR contributors.

While the C# field keyword is preferred for standard properties with backing logic, ReactiveUI's reactive properties must continue to use the canonical RaiseAndSetIfChanged pattern with an explicit backing field. This is because RaiseAndSetIfChanged is a ref-passing API.

Example pattern:

private string _name;
public string Name
{
    get => _name;
    set => this.RaiseAndSetIfChanged(ref _name, value);
}

To maintain high performance and clean code, follow these C# patterns:

• Flatten the happy path: Use guard clauses and early return or continue to avoid nested if/else blocks.
• Prefer switch expressions: Use switch expressions over if/else chains where possible (e.g., property patterns like { HasValue: true }).
• Use list patterns for collections: Use is [] for empty collections, is [_, ..] for non-empty, and is [var single] to bind a single-element collection.
• Use is / is not: Prefer these for null and type checks over == or !=.
• Avoid while (true): Express termination conditions in the loop header, such as while (!cancellationToken.IsCancellationRequested).

For async paths (e.g., ReactiveCommand.CreateFromTask, interaction handlers), adhere to these standards:

• No sync-over-async: Never use .GetAwaiter().GetResult(), .Result, or .Wait().
• Use ConfigureAwait(false): Apply this to every library await in production code.
• Propagate Cancellation: Always pass CancellationToken through the pipeline. Use CancellationTokenSource.CreateLinkedTokenSource once at subscribe time rather than per emission.
• Prefer ValueTask for zero-alloc paths: Use ValueTask when implementations frequently complete synchronously. Use Task for I/O-dominant or cold paths. Remember the consume-once rule for ValueTask (do not await the same instance twice).
• Return completed tasks directly: For synchronous implementations, return ValueTask.CompletedTask or Task.CompletedTask to avoid state machine allocations.

While string is a first-class type in ReactiveUI, follow these rules to avoid unnecessary allocations:

• Lazy string building: Do not use string interpolation or string.Format inside per-emission paths for values that might only be used on failure. Build the message lazily on the throw path.
• Use nameof(...): Always use nameof(...) instead of string literals for member references.
• Ordinal comparisons: Use StringComparer.Ordinal or StringComparison.Ordinal for identifier, type-name, and property-name comparisons.
• Use Spans for parsing: Use ReadOnlySpan<char> and range expressions (e.g., path[..i]) instead of Substring when slicing member paths.

As of May 2024, ReactiveUI has removed support for legacy Xamarin platforms. Users should migrate to .NET MAUI using the following mappings:

• Xamarin.Forms $\rightarrow$ MAUI (using ReactiveUI.Maui)
• Xamarin.Android $\rightarrow$ MAUI Android or AndroidX (using ReactiveUI.AndroidX for native Android)
• Xamarin.iOS/Mac $\rightarrow$ MAUI iOS/Mac Catalyst