Contains the ReactiveUI platform specific extensions for Avalonia
$ dotnet add package ReactiveUI.Avalonia
This package provides ReactiveUI bindings and helpers for the Avalonia UI framework, enabling you to build composable, cross-platform model-view-viewmodel (MVVM) applications for Windows, macOS, and Linux.
Install the packages that match your preferred dependency injection container. The core package is always required.
All libraries target multiple frameworks including .NET Standard 2.0 and modern .NET (.NET 8/9/10) for broad compatibility.
The recommended approach for new projects is to use the ReactiveUIBuilder via the UseReactiveUI and UseReactiveUIWith... extensions. This ensures consistent registration of schedulers, activation/binding hooks, and view discovery.
Namespaces to import in your startup:
using Avalonia; // AppBuilder
using ReactiveUI.Avalonia; // UseReactiveUI, RegisterReactiveUIViews* (core)
using ReactiveUI.Avalonia.Splat; // Autofac, DryIoc, Ninject, Microsoft.Extensions.DependencyInjection integrationsMinimal setup (no external DI container):
public static class Program
{
public static void Main(string[] args) => BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
public static AppBuilder BuildAvaloniaApp() => AppBuilder
.Configure<App>()
.UsePlatformDetect()
.UseReactiveUI(rxui =>
{
// Optional: add custom registration here via rxui.WithRegistration(...)
})
.RegisterReactiveUIViewsFromEntryAssembly();
}With Autofac:
public static AppBuilder BuildAvaloniaApp() => AppBuilder
.Configure<App>()
.UsePlatformDetect()
.UseReactiveUIWithAutofac(
container =>
{
// Register your services/view models
// container.RegisterType<MainViewModel>();
},
withResolver: resolver =>
{
// Optional: access the Autofac resolver/lifetime scope
},
withReactiveUIBuilder: rxui =>
{
// Optional: add ReactiveUI customizations
})
.RegisterReactiveUIViewsFromEntryAssembly();With DryIoc:
public static AppBuilder BuildAvaloniaApp() => AppBuilder
.Configure<App>()
.UsePlatformDetect()
.UseReactiveUIWithDryIoc(
container =>
{
// container.Register<MainViewModel>(Reuse.Singleton);
},
withReactiveUIBuilder: rxui =>
{
// Optional ReactiveUI customizations
})
.RegisterReactiveUIViewsFromEntryAssembly();With Microsoft.Extensions.DependencyInjection:
public static AppBuilder BuildAvaloniaApp() => AppBuilder
.Configure<App>()
.UsePlatformDetect()
.UseReactiveUIWithMicrosoftDependencyResolver(
services =>
{
// services.AddSingleton<MainViewModel>();
},
withResolver: sp =>
{
// Optional: access ServiceProvider
})
;Note: UseReactiveUIWithMicrosoftDependencyResolver(...) builds the ServiceProvider during setup, so make sure you register all services (including any IViewFor<T> views) in the services => { ... } callback.
With Ninject:
public static AppBuilder BuildAvaloniaApp() => AppBuilder
.Configure<App>()
.UsePlatformDetect()
.UseReactiveUIWithNinject(
kernel =>
{
// kernel.Bind<MainViewModel>().ToSelf().InSingletonScope();
},
withReactiveUIBuilder: rxui =>
{
// Optional ReactiveUI customizations
})
.RegisterReactiveUIViewsFromEntryAssembly();Notes
UseReactiveUI sets RxApp.MainThreadScheduler to AvaloniaScheduler.Instance and registers the Avalonia-specific activation and binding services.RegisterReactiveUIViewsFromEntryAssembly() scans your entry assembly and registers any types implementing IViewFor<TViewModel> for view location/navigation.UseReactiveUI() without a DI container and register services into Splat directly if you prefer.You can configure a custom container using the generic UseReactiveUIWithDIContainer if you don’t use one of the provided integrations:
AppBuilder
.Configure<App>()
.UseReactiveUIWithDIContainer(
containerFactory: () => new MyContainer(),
containerConfig: container =>
{
// configure container
},
dependencyResolverFactory: container => new MySplatResolver(container))
.RegisterReactiveUIViewsFromEntryAssembly();// View model
using ReactiveUI;
public class MyViewModel : ReactiveObject
{
private string _greeting = "Hello, Reactive World!";
public string Greeting
{
get => _greeting;
set => this.RaiseAndSetIfChanged(ref _greeting, value);
}
}<!-- MainView.axaml -->
<UserControl x:Class="MyAvaloniaApp.Views.MainView"
xmlns="https://github.com/avaloniaui"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:rxui="using:ReactiveUI.Avalonia">
<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
<TextBlock x:Name="GreetingTextBlock" FontSize="24"/>
</StackPanel>
</UserControl>// MainView.axaml.cs
using ReactiveUI;
using ReactiveUI.Avalonia;
using System.Reactive.Disposables;
public partial class MainView : ReactiveUserControl<MyViewModel>
{
public MainView()
{
InitializeComponent();
ViewModel = new MyViewModel();
this.WhenActivated(disposables =>
{
this.OneWayBind(ViewModel, vm => vm.Greeting, v => v.GreetingTextBlock.Text)
.DisposeWith(disposables);
});
}
}Key extension methods on AppBuilder:
UseReactiveUI() — initialize ReactiveUI for Avalonia (scheduler, activation, bindings)UseReactiveUI(Action<ReactiveUIBuilder>) — initialize with the ReactiveUIBuilder for additional configurationRegisterReactiveUIViews(params Assembly[]) — scan and register views implementing IViewFor<T>RegisterReactiveUIViewsFromEntryAssembly() — convenience overload to scan the entry assemblyRegisterReactiveUIViewsFromAssemblyOf<TMarker>() — scan a specific assemblyUseReactiveUIWithDIContainer<TContainer>(...) — bring-your-own container integration via an IDependencyResolverImportant types registered by default:
IActivationForViewFetcher ? AvaloniaActivationForViewFetcherIPropertyBindingHook ? AutoDataTemplateBindingHookICreatesCommandBinding ? AvaloniaCreatesCommandBindingICreatesObservableForProperty ? AvaloniaObjectObservableForPropertyRxApp.MainThreadScheduler set to AvaloniaScheduler.InstanceControls and helpers:
RoutedViewHost — view host that displays the view for the current RoutingStateReactiveUserControl<TViewModel>, ReactiveWindow<TViewModel> — base classes for reactive viewsExtension methods on AppBuilder (namespace Avalonia.ReactiveUI.Splat):
UseReactiveUIWithAutofac(Action<ContainerBuilder> containerConfig, Action<AutofacDependencyResolver>? withResolver = null)UseReactiveUIWithAutofac(Action<ContainerBuilder> containerConfig, Action<AutofacDependencyResolver>? withResolver = null, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null)What it does:
Splat with Autofac, initializes ReactiveUI for Avalonia, builds your container, and optionally exposes the Autofac resolver.Extension methods on AppBuilder (namespace ReactiveUI.Avalonia.Splat):
UseReactiveUIWithDryIoc(Action<Container> containerConfig)UseReactiveUIWithDryIoc(Action<Container> containerConfig, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null)What it does:
Splat to DryIoc, initializes ReactiveUI for Avalonia, and lets you register services on the container.Extension methods on AppBuilder (namespace ReactiveUI.Avalonia.Splat):
UseReactiveUIWithMicrosoftDependencyResolver(Action<IServiceCollection> containerConfig, Action<IServiceProvider?>? withResolver = null)UseReactiveUIWithMicrosoftDependencyResolver(Action<IServiceCollection> containerConfig, Action<IServiceProvider?>? withResolver = null, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null)What it does:
Splat using IServiceCollection/ServiceProvider, initializes ReactiveUI for Avalonia, and exposes the built provider if you need it.Extension methods on AppBuilder (namespace ReactiveUI.Avalonia.Splat):
UseReactiveUIWithNinject(Action<StandardKernel> containerConfig)UseReactiveUIWithNinject(Action<StandardKernel> containerConfig, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null)What it does:
Splat to Ninject, initializes ReactiveUI for Avalonia, and lets you configure bindings on the kernel.Welcome to the ReactiveUI.Avalonia guide! This tutorial walks you through setting up an Avalonia app with ReactiveUI. We start with the basics and build up to a reactive application.
ReactiveUI.Avalonia provides the necessary bindings and helpers to seamlessly integrate the ReactiveUI MVVM framework with your Avalonia projects, enabling elegant, testable, and maintainable code.
Add the ReactiveUI.Avalonia package to your Avalonia application project file.
<PackageReference Include="ReactiveUI.Avalonia" Version="11.3.0" />Use the builder-based setup shown above (see "Recommended setup"). For a minimal variant:
AppBuilder.Configure<App>()
.UsePlatformDetect()
.UseReactiveUI()
.RegisterReactiveUIViewsFromEntryAssembly();using ReactiveUI;
public class MyViewModel : ReactiveObject
{
private string _greeting;
public string Greeting
{
get => _greeting;
set => this.RaiseAndSetIfChanged(ref _greeting, value);
}
public MyViewModel() => Greeting = "Hello, Reactive World!";
}<!-- MainView.axaml -->
<UserControl x:Class="MyAvaloniaApp.Views.MainView"
xmlns="https://github.com/avaloniaui"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:rxui="using:ReactiveUI.Avalonia">
<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
<TextBlock x:Name="GreetingTextBlock" FontSize="24"/>
</StackPanel>
</UserControl>// MainView.axaml.cs
using ReactiveUI;
using ReactiveUI.Avalonia;
using System.Reactive.Disposables;
public partial class MainView : ReactiveUserControl<MyViewModel>
{
public MainView()
{
InitializeComponent();
ViewModel = new MyViewModel();
this.WhenActivated(disposables =>
{
this.OneWayBind(ViewModel, vm => vm.Greeting, v => v.GreetingTextBlock.Text)
.DisposeWith(disposables);
});
}
}Add a command to the view model and bind it in the view.
using ReactiveUI;
using System;
using System.Reactive;
public class MyViewModel : ReactiveObject
{
public ReactiveCommand<Unit, Unit> GenerateGreetingCommand { get; }
private string _greeting = "Hello, Reactive World!";
public string Greeting
{
get => _greeting;
set => this.RaiseAndSetIfChanged(ref _greeting, value);
}
public MyViewModel()
{
GenerateGreetingCommand = ReactiveCommand.Create(() =>
{
Greeting = $"Hello from Avalonia! The time is {DateTime.Now.ToLongTimeString()}";
});
}
}<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
<TextBlock x:Name="GreetingTextBlock" FontSize="24"/>
<Button x:Name="GenerateGreetingButton" Content="Generate" Margin="0,20,0,0"/>
</StackPanel>this.WhenActivated(disposables =>
{
this.OneWayBind(ViewModel, vm => vm.Greeting, v => v.GreetingTextBlock.Text)
.DisposeWith(disposables);
this.BindCommand(ViewModel, vm => vm.GenerateGreetingCommand, v => v.GenerateGreetingButton)
.DisposeWith(disposables);
});RoutedViewHostSet up a router and display views based on navigation state.
using ReactiveUI;
public class AppViewModel : ReactiveObject, IScreen
{
public RoutingState Router { get; } = new RoutingState();
public AppViewModel() => Router.Navigate.Execute(new MyViewModel());
}<!-- MainWindow.axaml -->
<Window xmlns="https://github.com/avaloniaui"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:rxui="using:ReactiveUI.Avalonia"
x:Class="MyAvaloniaApp.MainWindow">
<Grid>
<rxui:RoutedViewHost Router="{Binding Router}" />
</Grid>
</Window>Register views manually or scan assemblies:
using ReactiveUI;
using ReactiveUI.Avalonia;
using Splat;
Locator.CurrentMutable.Register(() => new MainView(), typeof(IViewFor<MyViewModel>));
// or:
AppBuilder.Configure<App>().UseReactiveUI().RegisterReactiveUIViewsFromEntryAssembly();We want to thank the following contributors and libraries that help make ReactiveUI.Avalonia possible:
The core team members, ReactiveUI contributors and contributors in the ecosystem do this open-source work in their free time. If you use ReactiveUI, a serious task, and you'd like us to invest more time on it, please donate. This project increases your income/productivity too. It makes development and applications faster and it reduces the required bandwidth.
This is how we use the donations:
If you have a question, please see if any discussions in our GitHub Discussions or GitHub issues have already answered it.
If you want to discuss something or just need help, here is our Slack room, where there are always individuals looking to help out!
Please do not open GitHub issues for support requests.
Please do not open GitHub issues for general support requests.
ReactiveUI.Avalonia is developed under an OSI-approved open source license, making it freely usable and distributable, even for commercial use.
If you want to submit pull requests please first open a GitHub issue to discuss. We are first time PR contributors friendly.
See Contribution Guidelines for further information how to contribute changes.
ReactiveUI.Avalonia is licensed under the MIT License.