A C# source generator that replaces ReactiveUI's runtime expression-tree binding engine with compile-time code generation. Zero reflection, fully AOT/trimming safe, 3-7x faster than the legacy engine.

• What does it do?
• How does it work?
• How do I install?
• Supported APIs
• Usage Examples
• Supported Notification Mechanisms
• Packages
• Rx Library Compatibility
• Performance
• Diagnostics
• Architecture
• Core Team
• Contribute

Chris Pulman London, UK

Glenn Watson Melbourne, Australia

ReactiveUI.Binding.SourceGenerators is an incremental source generator that analyses your WhenChanged, WhenChanging, WhenAnyValue, WhenAny, WhenAnyObservable, BindOneWay, BindTwoWay, OneWayBind, and Bind call sites at compile time and emits optimised, strongly-typed observation and binding code. It eliminates:

• Runtime expression-tree compilation -- no Expression<Func<T>> evaluation at runtime
• Reflection -- all property access is generated as direct member access
• System.Reactive dependency in the base package -- generated code uses lightweight built-in observables

The result is binding code that is AOT-safe, trimming-safe, and significantly faster than the legacy ReactiveUI binding engine.

The generator runs two pipelines during compilation:

Pipeline A (Type Detection) scans your types for notification mechanisms (INotifyPropertyChanged, IReactiveObject, WPF DependencyObject, WinUI DependencyObject, Apple KVO, WinForms Component, Android View) and registers per-type observation factories via a [ModuleInitializer].

Pipeline B (Invocation Detection) scans method invocations and extracts lambda property paths at compile time. Each call site is identified by [CallerFilePath] + [CallerLineNumber], and the generator emits a per-call-site optimised method that is dispatched to at runtime via a generated lookup table.

// You write:
var obs = vm.WhenChanged(x => x.Name);

// The generator emits a dispatch stub that captures caller info:
public static IObservable<TReturn> WhenChanged<TObj, TReturn>(
    this TObj obj, Expression<Func<TObj, TReturn>> property,
    [CallerFilePath] string callerFilePath = "",
    [CallerLineNumber] int callerLineNumber = 0) where TObj : class
{
    if (__GeneratedBindingDispatcher.TryGetWhenChanged(callerFilePath, callerLineNumber, obj, out var result))
        return (IObservable<TReturn>)result!;
    throw new InvalidOperationException("No generated binding found.");
}

// And a per-call-site method with direct property access:
private static IObservable<string> __WhenChanged_0(MyViewModel obj)
{
    return new PropertyObservable<string>(
        obj, "Name", static o => ((MyViewModel)o).Name, true);
}

Install the ReactiveUI.Binding NuGet package. The source generator is automatically included.

dotnet add package ReactiveUI.Binding

If you need IScheduler overloads (e.g. ObserveOn), also install the adapter package:

dotnet add package ReactiveUI.Binding.Reactive

Platform-specific packages provide DependencyProperty observation and other platform integrations:

All APIs support single properties, deep property chains (e.g. x => x.Address.City), and multi-property observation (up to 12 properties for WhenAnyValue/WhenChanged).

// Single property
IObservable<string> nameObs = vm.WhenChanged(x => x.Name);

// Deep chain -- re-subscribes when intermediate objects change
IObservable<string> cityObs = vm.WhenChanged(x => x.Address.City);

// Multiple properties with selector
IObservable<string> fullName = vm.WhenChanged(
    x => x.FirstName,
    x => x.LastName,
    (first, last) => $"{first} {last}");

// Before-change observation (requires INotifyPropertyChanging)
IObservable<string> nameChanging = vm.WhenChanging(x => x.Name);

// Bind source property to target property
IDisposable binding = vm.BindOneWay(view, x => x.Name, x => x.NameLabel);

// With converter
IDisposable binding = vm.BindOneWay(view,
    x => x.Age,
    x => x.AgeLabel,
    age => $"Age: {age}");

// Bind source and target properties bidirectionally
IDisposable binding = vm.BindTwoWay(view, x => x.Name, x => x.NameTextBox);

// With converters
IDisposable binding = vm.BindTwoWay(view,
    x => x.Age,
    x => x.AgeTextBox,
    age => age.ToString(),
    text => int.TryParse(text, out var n) ? n : 0);

// WhenAnyValue is a drop-in replacement for ReactiveUI.WhenAnyValue
IObservable<string> obs = vm.WhenAnyValue(x => x.Name);

// OneWayBind / Bind match ReactiveUI's binding API
IDisposable binding = view.OneWayBind(vm, x => x.Name, x => x.NameLabel);
IDisposable binding = view.Bind(vm, x => x.Name, x => x.NameTextBox);

Scheduler overloads require the ReactiveUI.Binding.Reactive package:

using ReactiveUI.Binding.Reactive;
using System.Reactive.Concurrency;

// Observe on a specific scheduler
IObservable<string> obs = vm.WhenChanged(x => x.Name, RxApp.MainThreadScheduler);

// Bind with scheduler
IDisposable binding = vm.BindOneWay(view, x => x.Name, x => x.NameLabel,
    scheduler: RxApp.MainThreadScheduler);

The source generator detects and generates optimised code for each platform's notification mechanism:

Higher affinity values take priority when a type implements multiple mechanisms.

Package	Description	NuGet
ReactiveUI.Binding	Runtime library with lightweight observables. No System.Reactive dependency.
ReactiveUI.Binding.SourceGenerators	Source generator (auto-referenced by the Binding package).
ReactiveUI.Binding.Reactive	System.Reactive adapter for IScheduler overloads.
ReactiveUI.Binding.Wpf	WPF DependencyProperty support.
ReactiveUI.Binding.WinForms	WinForms Component support.
ReactiveUI.Binding.Maui	MAUI BindableProperty support.

The base ReactiveUI.Binding package has no dependency on System.Reactive. All generated code returns IObservable<T> (the BCL interface), making it compatible with any Rx implementation.

All benchmarks use 1,000 property changes per iteration. Measured on AMD Ryzen 7 5800X, .NET SDK 10.0.102.

Source-Generated (this project):

ReactiveUI Expression-Tree Engine (baseline):

Summary:

The ReactiveUI expression-tree engine cannot run under NativeAOT due to its use of runtime reflection and expression compilation. The source-generated engine runs under NativeAOT with an additional 6x speedup over JIT.

Source-Generated:

ReactiveUI Expression-Tree Engine:

Summary:

The separate analyzer package reports the following diagnostics:

src/
  ReactiveUI.Binding/                        Runtime library, lightweight observables, IObservable<T>
  ReactiveUI.Binding.SourceGenerators/       Incremental source generator (netstandard2.0)
  ReactiveUI.Binding.Analyzer/              Roslyn analyzer for RXUIBIND diagnostics
  ReactiveUI.Binding.Reactive/              System.Reactive adapter (IScheduler overloads)
  ReactiveUI.Binding.Wpf/                   WPF DependencyProperty integration
  ReactiveUI.Binding.WinForms/              WinForms Component integration
  ReactiveUI.Binding.Maui/                  MAUI BindableProperty integration

The generator and analyzer both target netstandard2.0 (Roslyn requirement). The runtime library targets .NET 8.0, 9.0, 10.0, and .NET Framework 4.6.2-4.8.1. Generated output is C# 7.3 compatible to support the widest range of consumer projects.

ReactiveUI.Binding.SourceGenerators is developed under an OSI-approved open source license, making it freely usable and distributable, even for commercial use. We value the people who are involved in this project, and we'd love to have you on board, especially if you are just getting started or have never contributed to open-source before.

So here's to you, lovely person who wants to join us -- this is how you can support us:

• Responding to questions on GitHub Discussions
• Passing on knowledge and teaching the next generation of developers
• Submitting documentation updates where you see fit or lacking.
• Making contributions to the code base.