### Complete Configuration Example with Autofac

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

A comprehensive example demonstrating how to configure ReactiveUI with Autofac for dependency injection, including registering ViewModels, Views, and Services, along with state persistence setup.

```csharp
public static class Program
{
    public static void Main(string[] args) => BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);

    public static AppBuilder BuildAvaloniaApp()
    {
        return AppBuilder
            .Configure<App>()
            .UsePlatformDetect()
            .WithInterFont()
            .UseReactiveUIWithAutofac(
                containerConfig: container =>
                {
                    // Register ViewModels
                    container.RegisterType<MainViewModel>().AsSelf().SingleInstance();
                    container.RegisterType<DetailsViewModel>().AsSelf();
                    
                    // Register Views
                    container.RegisterType<MainView>().As<IViewFor<MainViewModel>>();
                    container.RegisterType<DetailsView>().As<IViewFor<DetailsViewModel>>();
                    
                    // Register Services
                    container.RegisterType<DataService>().As<IDataService>().SingleInstance();
                    container.RegisterType<HttpClientFactory>().AsSelf().SingleInstance();
                },
                withReactiveUIBuilder: rxui =>
                {
                    // Optional additional configuration
                })
            .RegisterReactiveUIViewsFromEntryAssembly();
    }
}

public partial class App : Application
{
    public override void OnFrameworkInitializationCompleted()
    {
        if (ApplicationLifetime is IControlledApplicationLifetime lifetime)
        {
            var suspendHelper = new AutoSuspendHelper(lifetime);
            
            RxSuspension.SuspensionHost.ShouldPersistState
                .SelectMany(_ => SaveStateAsync())
                .Subscribe();
            
            suspendHelper.OnFrameworkInitializationCompleted();
        }
        
        base.OnFrameworkInitializationCompleted();
    }
    
    private async Task<Unit> SaveStateAsync()
    {
        // Save application state
        return Unit.Default;
    }
}
```

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

### Quick example: first reactive view

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Demonstrates a basic setup for a reactive view model and its corresponding Avalonia view, including data binding.

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

```xml
<!-- 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>
```

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

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

### Setup With Ninject

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Setup for ReactiveUI.Avalonia using Ninject for dependency injection.

```csharp
.UseReactiveUIWithNinject(kernel =>
{
    kernel.Bind<MainViewModel>().ToSelf().InSingletonScope();
    kernel.Bind<IViewFor<MainViewModel>>().To<MainView>();
})
```

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

### Setup With Autofac

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Setup for ReactiveUI.Avalonia using Autofac for dependency injection.

```csharp
.UseReactiveUIWithAutofac(container =>
{
    container.RegisterType<MainViewModel>();
    container.RegisterType<MainView>();
})
.RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Setup With DryIoc

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Setup for ReactiveUI.Avalonia using DryIoc for dependency injection.

```csharp
.UseReactiveUIWithDryIoc(container =>
{
    container.Register<MainViewModel>(Reuse.Singleton);
    container.Register<MainView>();
})
```

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

### Rebase and force push

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/CONTRIBUTING.md

Example of how to rebase and force push to update a PR if it gets outdated.

```shell
git rebase master -i
git push origin my-fix-branch -f
```

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

### Setup With Microsoft DI

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Setup for ReactiveUI.Avalonia using Microsoft's built-in dependency injection.

```csharp
.UseReactiveUIWithMicrosoftDependencyResolver(services =>
{
    services.AddSingleton<MainViewModel>();
    services.AddSingleton<MainView>();
})
```

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

### ViewModel and Navigation Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

Example ViewModel with RoutingState and navigation commands.

```csharp
// ViewModel
public class AppViewModel : ReactiveObject, IScreen
{
    public RoutingState Router { get; }

    public AppViewModel()
    {
        Router = new RoutingState();
        Router.Navigate.Execute(new HomeViewModel());
    }
}

// Navigation
// Assuming 'Router' is accessible, e.g., from the ViewModel
// Router.Navigate.Execute(new DetailsViewModel());
```

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

### UseReactiveUI Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AppBuilderExtensions.md

Example of configuring Avalonia AppBuilder with ReactiveUI and registering views.

```csharp
public static AppBuilder BuildAvaloniaApp() => AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUI(rxui =>
    {
        // Optional: add custom registration here via rxui.WithRegistration(...)
    })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### View Registration Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

Examples of manual and automatic view registration.

```csharp
// Manual registration
Locator.CurrentMutable.Register(
    () => new MainView(),
    typeof(IViewFor<MainViewModel>));

// With contract
Locator.CurrentMutable.Register(
    () => new MainViewAdvanced(),
    typeof(IViewFor<MainViewModel>),
    "Advanced");

// Automatic scanning
AppBuilder.Configure<App>()
    .UseReactiveUI()
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### RegisterReactiveUIViewsFromEntryAssembly Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AppBuilderExtensions.md

Example of using RegisterReactiveUIViewsFromEntryAssembly during application startup.

```csharp
AppBuilder.Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUI()
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### RegisterReactiveUIViews Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AppBuilderExtensions.md

Example of registering ReactiveUI views from specific assemblies.

```csharp
// Register views from specific assemblies
AppBuilder.Configure<App>()
    .RegisterReactiveUIViews(typeof(MyView).Assembly, typeof(OtherView).Assembly);
```

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

### Service Registration During Setup

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Registers a service instance during the ReactiveUI setup.

```csharp
.UseReactiveUI(rxui =>
{
    rxui.WithRegistration(splat =>
    {
        splat.RegisterConstant<IMyService>(new MyService());
    });
})
```

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

### Minimal Setup (No DI Container)

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

This is the minimal setup for ReactiveUI.Avalonia without using an external DI container. It uses Splat for service location and automatically discovers views from the entry assembly.

```csharp
public static AppBuilder BuildAvaloniaApp() => AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUI()
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Reactive Command

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of creating a basic reactive command that can be executed.

```csharp
public ReactiveCommand<Unit, Unit> MyCommand { get; }

public MyViewModel()
{
    MyCommand = ReactiveCommand.Create(() =>
    {
        // Handle click
    });
}
```

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

### Avalonia XAML Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

Example of how to use RoutedViewHost in Avalonia XAML.

```xml
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:rxui="using:ReactiveUI.Avalonia"
        x:Class="MyAvaloniaApp.MainWindow"
        DataContext="{Binding AppViewModel}">
    <Grid>
        <rxui:RoutedViewHost Router="{Binding Router}">
            <rxui:RoutedViewHost.DefaultContent>
                <TextBlock Text="Welcome"/>
            </rxui:RoutedViewHost.DefaultContent>
        </rxui:RoutedViewHost>
    </Grid>
</Window>
```

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

### Minimal Setup

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Sets up the Avalonia application with ReactiveUI integration.

```csharp
public static class Program
{
    public static void Main(string[] args) 
        => BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);

    public static AppBuilder BuildAvaloniaApp() => AppBuilder
        .Configure<App>()
        .UsePlatformDetect()
        .UseReactiveUI()
        .RegisterReactiveUIViewsFromEntryAssembly();
}
```

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

### Property as Observable

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of getting an observable stream from a control's property using GetSubject.

```csharp
var subject = textBox.GetSubject(TextBox.TextProperty);

subject
    .Debounce(TimeSpan.FromMilliseconds(500))
    .Subscribe(text => Debug.WriteLine($"Search: {text}"));
```

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

### Commands Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Shows how to define and create a ReactiveCommand.

```csharp
public ReactiveCommand<Unit, Unit> MyCommand { get; }

public MyViewModel()
{
    MyCommand = ReactiveCommand.Create(() =>
    {
        // Handle command
    });
}
```

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

### ReactiveCommand Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/types.md

Example of creating and using a ReactiveCommand.

```csharp
public ReactiveCommand<Unit, Unit> GenerateGreetingCommand { get; }

public ViewModel()
{
    GenerateGreetingCommand = ReactiveCommand.Create(() =>
    {
        Greeting = "Hello!";
    });
}
```

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

### Minimal setup (no external DI container)

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Basic ReactiveUI setup using AppBuilder without integrating an external dependency injection container.

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

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

### Example Usage of ReactiveWindow<TViewModel>

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ReactiveControls.md

An example demonstrating how to use ReactiveWindow in a view, including ViewModel binding and activation handling.

```csharp
public partial class MainWindow : ReactiveWindow<MainViewModel>
{
    public MainWindow()
    {
        InitializeComponent();
        ViewModel = new MainViewModel();

        this.WhenActivated(disposables =>
        {
            this.OneWayBind(ViewModel, vm => vm.Title, v => v.Title)
                .DisposeWith(disposables);
        });
    }
}
```

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

### Navigation Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Demonstrates how to set up navigation using RoutingState and RoutedViewHost.

```csharp
public class AppViewModel : ReactiveObject, IScreen
{
    public RoutingState Router { get; } = new RoutingState();
}

// In view:
<rxui:RoutedViewHost Router="{Binding Router}"/>

// In code:
Router.Navigate.Execute(new DetailViewModel());
```

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

### Constructor Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AutoSuspendHelper.md

Example of how to initialize AutoSuspendHelper with an IControlledApplicationLifetime.

```csharp
public override void OnFrameworkInitializationCompleted()
{
    if (ApplicationLifetime is IControlledApplicationLifetime lifetime)
    {
        var suspendHelper = new AutoSuspendHelper(lifetime);
        suspendHelper.OnFrameworkInitializationCompleted();
    }
    
    base.OnFrameworkInitializationCompleted();
}
```

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

### State Persistence Setup

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Sets up state persistence for the application using AutoSuspendHelper and RxSuspension.

```csharp
public override void OnFrameworkInitializationCompleted()
{
    if (ApplicationLifetime is IControlledApplicationLifetime lifetime)
    {
        var suspendHelper = new AutoSuspendHelper(lifetime);
        
        RxSuspension.SuspensionHost.ShouldPersistState
            .SelectMany(_ => SaveStateAsync())
            .Subscribe();
        
        suspendHelper.OnFrameworkInitializationCompleted();
    }
    
    base.OnFrameworkInitializationCompleted();
}

private async Task<Unit> SaveStateAsync()
{
    var state = new { /* state */ };
    var json = JsonConvert.SerializeObject(state);
    await File.WriteAllTextAsync("state.json", json);
    return Unit.Default;
}
```

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

### Ninject Integration Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

An example of how to use the UseReactiveUIWithNinject method.

```csharp
using ReactiveUI.Avalonia.Splat;
using Ninject;

AppBuilder.Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithNinject(
        containerConfig: kernel =>
        {
            kernel.Bind<MainViewModel>().ToSelf().InSingletonScope();
            kernel.Bind<IViewFor<MainViewModel>>().To<MainView>().InSingletonScope();
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Microsoft.Extensions.DependencyInjection Integration Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

An example of how to use the UseReactiveUIWithMicrosoftDependencyResolver method.

```csharp
using ReactiveUI.Avalonia.Splat;
using Microsoft.Extensions.DependencyInjection;

AppBuilder.Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithMicrosoftDependencyResolver(
        containerConfig: services =>
        {
            services.AddSingleton<MainViewModel>();
            services.AddSingleton<MainView>();
        },
        withResolver: serviceProvider =>
        {
            // Access the built ServiceProvider if needed
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        });
```

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

### Window Template

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of creating a ReactiveWindow in C# with title binding.

```csharp
public partial class MainWindow : ReactiveWindow<MainViewModel>
{
    public MainWindow()
    {
        InitializeComponent();
        ViewModel = new MainViewModel();
        
        this.WhenActivated(disposables =>
        {
            this.OneWayBind(ViewModel, vm => vm.Title, v => v.Title)
                .DisposeWith(disposables);
        });
    }
}
```

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

### BindingValue Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/types.md

Example demonstrating the usage of BindingValue.

```csharp
var bindingValue = new BindingValue<string>("text");
if (bindingValue.HasValue)
{
    var text = bindingValue.Value; // "text"
}
```

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

### View Navigation With Contracts

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of using view contracts for navigation, showing registration and usage.

```csharp
// Register with contract
[ViewContract("Advanced")]
public class DetailsViewAdvanced : ReactiveUserControl<DetailsViewModel> { }

// Use contract
<rxui:RoutedViewHost Router="{Binding Router}" ViewContract="Advanced"/>
```

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

### Basic Navigation

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of setting up basic view navigation using RoutingState in a ViewModel and RoutedViewHost in XAML.

```csharp
// ViewModel
public class AppViewModel : ReactiveObject, IScreen
{
    public RoutingState Router { get; } = new RoutingState();
    
    public void NavigateToDetails() => Router.Navigate.Execute(new DetailsViewModel());
}

// XAML
<rxui:RoutedViewHost Router="{Binding Router}"/>
```

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

### Async Command

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of creating a reactive command that executes an asynchronous operation.

```csharp
public ReactiveCommand<Unit, string> FetchDataCommand { get; }

public MyViewModel()
{
    FetchDataCommand = ReactiveCommand.CreateFromTask(async () =>
    {
        return await FetchDataAsync();
    });
}
```

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

### Registering Views

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Examples of how to register views with the Locator for navigation.

```csharp
using ReactiveUI;
using ReactiveUI.Avalonia;
using Splat;

Locator.CurrentMutable.Register(() => new MainView(), typeof(IViewFor<MyViewModel>));
// or:
AppBuilder.Configure<App>().UseReactiveUI().RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Example Usage of ReactiveUserControl<TViewModel>

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ReactiveControls.md

An example demonstrating how to use ReactiveUserControl in a view, including ViewModel binding and activation handling.

```csharp
public partial class MainView : ReactiveUserControl<MainViewModel>
{
    public MainView()
    {
        InitializeComponent();
        ViewModel = new MainViewModel();

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

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

### Reactive Programming Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/Architecture.md

An example demonstrating the use of Observables, Select, ObserveOn, and Subscribe for handling asynchronous sequences and UI updates.

```csharp
observable
    .Select(x => Process(x))
    .ObserveOn(AvaloniaScheduler.Instance)
    .Subscribe(value => UpdateUI(value));
```

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

### ViewModelViewHost XAML Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

Example of using ViewModelViewHost in XAML to display a ViewModel with its associated view and default content.

```xaml
<rxui:ViewModelViewHost ViewModel="{Binding CurrentViewModel}">
    <rxui:ViewModelViewHost.DefaultContent>
        <TextBlock Text="No view available"/>
    </rxui:ViewModelViewHost.DefaultContent>
</rxui:ViewModelViewHost>

<!-- With view contracts -->
<rxui:ViewModelViewHost ViewModel="{Binding CurrentViewModel}" 
                        ViewContract="Advanced"/>
```

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

### Push branch to GitHub

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/CONTRIBUTING.md

Example of how to push a local branch to GitHub.

```shell
git push origin my-fix-branch
```

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

### View Contracts Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Defining and using view contracts for multiple view implementations.

```csharp
[ViewContract("Advanced")]
public partial class MainViewAdvanced : ReactiveUserControl<MainViewModel>
{
    // ...
}
```

```xml
<rxui:RoutedViewHost Router="{Binding Router}" ViewContract="Advanced"/>
```

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

### XAML View

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example XAML for a ReactiveUserControl, defining UI elements.

```xml
<rxui:ReactiveUserControl x:Class="MyApp.Views.MyView"
                          xmlns="https://github.com/avaloniaui"
                          xmlns:rxui="using:ReactiveUI.Avalonia">
    <StackPanel>
        <TextBlock x:Name="TextBlock"/>
        <Button x:Name="MyButton" Content="Click"/>
    </StackPanel>
</rxui:ReactiveUserControl>
```

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

### Common Setup Pattern

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

The basic pattern for integrating DI containers with ReactiveUI.Avalonia.

```csharp
using ReactiveUI.Avalonia.Splat;

AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUI[WithContainerName](
        containerConfig: container =>
        {
            // Register your services
            RegisterServices(container);
        },
        // Optional: access the resolver/provider
        withResolver: resolver =>
        {
            // Any additional setup with the resolver
        },
        // Optional: customize ReactiveUI (except Ninject)
        withReactiveUIBuilder: rxui =>
        {
            // Custom ReactiveUI configuration
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Bind Commands

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Example of binding a command to a button.

```csharp
this.BindCommand(ViewModel, vm => vm.MyCommand, v => v.MyButton);
```

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

### Setup with DryIoc

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Integrating ReactiveUI with DryIoc for dependency injection in Avalonia applications.

```csharp
public static AppBuilder BuildAvaloniaApp() => AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithDryIoc(
        container =>
        {
            // container.Register<MainViewModel>(Reuse.Singleton);
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Prerequisites

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/CLAUDE.md

Commands to check .NET installation and restore NuGet packages using the SLNX format.

```powershell
# Check .NET installation
dotnet --info

# Restore NuGet packages
dotnet restore ReactiveUI.Avalonia.slnx
```

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

### Manual setup (without container mixins)

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Configuring a custom dependency injection container with ReactiveUI using the generic `UseReactiveUIWithDIContainer` extension.

```csharp
AppBuilder
    .Configure<App>()
    .UseReactiveUIWithDIContainer(
        containerFactory: () => new MyContainer(),
        containerConfig: container =>
        {
            // configure container
        },
        dependencyResolverFactory: container => new MySplatResolver(container))
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Setup with Microsoft.Extensions.DependencyInjection

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Integrating ReactiveUI with Microsoft.Extensions.DependencyInjection for dependency injection in Avalonia applications.

```csharp
public static AppBuilder BuildAvaloniaApp() => AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithMicrosoftDependencyResolver(
        services =>
        {
            // services.AddSingleton<MainViewModel>();
        },
        withResolver: sp =>
        {
            // Optional: access ServiceProvider
        })
```

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

### Nested Views

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of using ViewModelViewHost for displaying nested views in XAML.

```xml
<rxui:ViewModelViewHost ViewModel="{Binding CurrentItem}"/>
```

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

### Setup with Autofac

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Integrating ReactiveUI with Autofac for dependency injection in Avalonia applications.

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

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

### Ninject Configuration

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Example of configuring ReactiveUI with Ninject for dependency injection.

```csharp
.UseReactiveUIWithNinject(
    containerConfig: kernel =>
    {
        // Register ViewModels
        kernel.Bind<MainViewModel>().ToSelf().InSingletonScope();
        
        // Register Views
        kernel.Bind<IViewFor<MainViewModel>>().To<MainView>().InSingletonScope();
        
        // Register Services
        kernel.Bind<IDataService>().To<DataService>().InSingletonScope();
        kernel.Bind<HttpClient>().ToSelf().InTransientScope();
    },
    withReactiveUIBuilder: rxui =>
    {
        // Optional: additional ReactiveUI config
    })
```

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

### Create a new git branch

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/CONTRIBUTING.md

Example of how to create a new git branch for making changes.

```shell
git checkout -b my-fix-branch master
```

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

### Schedule Method Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaScheduler.md

Examples of scheduling work on the UI thread immediately and with a delay using AvaloniaScheduler.

```csharp
// Schedule work on the UI thread immediately
AvaloniaScheduler.Instance.Schedule(
    state: Unit.Default,
    dueTime: TimeSpan.Zero,
    action: (scheduler, _) =>
    {
        // This runs on the Avalonia UI thread
        textBlock.Text = "Updated";
        return Disposable.Empty;
    });

// Schedule work with delay
AvaloniaScheduler.Instance.Schedule(
    state: "delayed action",
    dueTime: TimeSpan.FromSeconds(2),
    action: (scheduler, data) =>
    {
        Debug.WriteLine($"Executed: {data}");
        return Disposable.Empty;
    });
```

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

### Bind Properties

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Examples of one-way and two-way property binding.

```csharp
this.OneWayBind(ViewModel, vm => vm.Property, v => v.TextBlock.Text);
this.Bind(ViewModel, vm => vm.Property, v => v.TextBox.Text);
```

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

### Setup with Ninject

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Integrating ReactiveUI with Ninject for dependency injection in Avalonia applications.

```csharp
public static AppBuilder BuildAvaloniaApp() => AppBuilder
    .Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithNinject(
        kernel =>
        {
            // kernel.Bind<MainViewModel>().ToSelf().InSingletonScope();
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### User Control Template

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of creating a ReactiveUserControl in C# with property and command binding.

```csharp
public partial class MyView : ReactiveUserControl<MyViewModel>
{
    public MyView()
    {
        InitializeComponent();
        ViewModel = new MyViewModel();
        
        this.WhenActivated(disposables =>
        {
            // Bind properties
            this.OneWayBind(ViewModel, vm => vm.Property, v => v.TextBlock.Text)
                .DisposeWith(disposables);
            
            // Bind commands
            this.BindCommand(ViewModel, vm => vm.MyCommand, v => v.MyButton)
                .DisposeWith(disposables);
        });
    }
}
```

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

### Command Binding

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of binding a ViewModel command to a View control's action.

```csharp
this.BindCommand(ViewModel, vm => vm.SaveCommand, v => v.SaveButton);
```

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

### Commit changes

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/CONTRIBUTING.md

Example of how to commit changes using the automatic add/remove option.

```shell
git commit -a
```

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

### Integration with Reactive Programming

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaObjectReactiveExtensions.md

Examples demonstrating reactive integration with Avalonia properties.

```csharp
// Transform property values reactively
textBox
    .GetSubject(TextBox.TextProperty)
    .Select(text => text?.Length ?? 0)
    .Subscribe(length => lengthLabel.Text = $"Length: {length}");
```

```csharp
// Combine multiple properties
Observable.CombineLatest(
    username.GetSubject(TextBox.TextProperty),
    password.GetSubject(TextBox.TextProperty)
)
.Select(x => x[0] != null && x[1] != null)
.Subscribe(isValid => loginButton.IsEnabled = isValid);
```

```csharp
// Two-way binding with debounce
searchBox
    .GetSubject(TextBox.TextProperty)
    .Debounce(TimeSpan.FromMilliseconds(300))
    .DistinctUntilChanged()
    .Subscribe(term => PerformSearch(term));
```

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

### Per-Control View Locator

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Example of setting a custom ViewLocator for a specific ViewModelViewHost.

```xml
<rxui:ViewModelViewHost ViewModel="{Binding CurrentViewModel}"
                        ViewLocator="{StaticResource MyCustomViewLocator}"/>
```

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

### View Registration with DI

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

Example of registering ViewModels and Views using DryIoc.

```csharp
.UseReactiveUIWithDryIoc(
    containerConfig: container =>
    {
        // Register ViewModels
        container.Register<MainViewModel>(Reuse.Singleton);
        container.Register<DetailViewModel>();

        // Register Views
        container.Register<MainView>();
        container.Register<DetailView>();
    })
.RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Integration with ReactiveUI Setup

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaScheduler.md

Example of how ReactiveUI automatically registers AvaloniaScheduler as the main thread scheduler during application setup.

```csharp
// Automatically sets RxApp.MainThreadScheduler to AvaloniaScheduler.Instance
AppBuilder.Configure<App>()
    .UseReactiveUI()
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Namespaces to import

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/README.md

Essential namespaces required for ReactiveUI setup in Avalonia applications.

```csharp
using Avalonia; // AppBuilder
using ReactiveUI.Avalonia; // UseReactiveUI, RegisterReactiveUIViews* (core)
using ReactiveUI.Avalonia.Splat; // Autofac, DryIoc, Ninject, Microsoft.Extensions.DependencyInjection integrations
```

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

### Observable Property

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of defining a reactive property using ReactiveObject and RaiseAndSetIfChanged.

```csharp
public class MyViewModel : ReactiveObject
{
    private string _name = "";
    public string Name
    {
        get => _name;
        set => this.RaiseAndSetIfChanged(ref _name, value);
    }
}
```

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

### Type Signatures Documentation Convention

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/README.md

Example of a type signature as used in documentation.

```csharp
public class ClassName
{
    public ReturnType MethodName(ParameterType parameterName)
}
```

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

### Immediate Execution Optimization Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaScheduler.md

Demonstrates the optimized path for immediate execution when scheduling with zero delay on the UI thread.

```csharp
// Optimized path: executes immediately without dispatcher posting
AvaloniaScheduler.Instance.Schedule(
    state: Unit.Default,
    dueTime: TimeSpan.Zero,
    action: (scheduler, _) => { /* ... */ });
```

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

### Typed Subject

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of getting a typed observable stream from a control's property using GetSubject.

```csharp
var subject = slider.GetSubject<double>(Slider.ValueProperty);

subject
    .Select(v => v * 100)
    .Subscribe(percent => label.Text = $"{percent}%");
```

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

### Custom View Locator Implementation

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/Architecture.md

Example implementation of IViewLocator for custom view resolution.

```csharp
public class CustomViewLocator : IViewLocator
{
    public IViewFor? ResolveView<T>(T? viewModel, string? contract = null)
        where T : class
    {
        // Custom resolution logic
        return new CustomView();
    }
}
```

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

### Microsoft.Extensions.DependencyInjection Configuration

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Example of configuring ReactiveUI with Microsoft.Extensions.DependencyInjection as the DI container. This includes registering ViewModels, Views, and Services.

```csharp
.UseReactiveUIWithMicrosoftDependencyResolver(
    containerConfig: services =>
    {
        // Register ViewModels
        services.AddSingleton<MainViewModel>();
        
        // Register Views
        services.AddSingleton<MainView>();
        
        // Register Services
        services.AddSingleton<IDataService, DataService>();
        services.AddTransient<HttpClient>();
        services.AddScoped<RepositoryService>();
    },
    withResolver: serviceProvider =>
    {
        // Optional: access the built ServiceProvider
        var dataService = serviceProvider.GetRequiredService<IDataService>();
    },
    withReactiveUIBuilder: rxui =>
    {
        // Optional: additional ReactiveUI config
    })
```

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

### Autofac Configuration

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Example of configuring ReactiveUI with Autofac as the DI container. This includes registering ViewModels, Views, and Services.

```csharp
.UseReactiveUIWithAutofac(
    containerConfig: builder =>
    {
        // Register ViewModels
        builder.RegisterType<MainViewModel>().AsSelf().SingleInstance();
        
        // Register Views
        builder.RegisterType<MainView>().As<IViewFor<MainViewModel>>();
        
        // Register Services
        builder.RegisterType<DataService>().As<IDataService>().SingleInstance();
        builder.RegisterType<HttpClient>().AsSelf().SingleInstance();
    },
    withResolver: resolver =>
    {
        // Optional: access the built resolver
        var container = resolver.GetService(typeof(ILifetimeScope)) as ILifetimeScope;
    },
    withReactiveUIBuilder: rxui =>
    {
        // Optional: additional ReactiveUI config
    })
```

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

### Multiple Binding

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of combining multiple observable values and binding the result to a View property.

```csharp
Observable.CombineLatest(
    this.WhenAnyValue(v => v.ViewModel!.FirstName),
    this.WhenAnyValue(v => v.ViewModel!.LastName))
    .Select(x => $"{x[0]} {x[1]}")
    .BindTo(this, v => v.FullNameLabel.Text);
```

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

### DryIoc Configuration

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Example of configuring ReactiveUI with DryIoc as the DI container. This includes registering ViewModels, Views, and Services.

```csharp
.UseReactiveUIWithDryIoc(
    containerConfig: container =>
    {
        // Register ViewModels
        container.Register<MainViewModel>(Reuse.Singleton);
        
        // Register Views
        container.Register<MainView>();
        
        // Register Services
        container.Register<IDataService, DataService>(Reuse.Singleton);
    },
    withReactiveUIBuilder: rxui =>
    {
        // Optional: additional ReactiveUI config
    })
```

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

### Autofac Integration Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

Configures the application to use ReactiveUI with Autofac as the dependency injection container.

```csharp
using ReactiveUI.Avalonia.Splat;
using Autofac;

AppBuilder.Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithAutofac(
        containerConfig: builder =>
        {
            builder.RegisterType<MainViewModel>().SingleInstance();
            builder.RegisterType<MainView>().As<IViewFor<MainViewModel>>();
        },
        withResolver: resolver =>
        {
            // Access the AutofacDependencyResolver if needed
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### WhenActivated Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/types.md

Example of using WhenActivated for ViewModel lifecycle management.

```csharp
public IObservable<Unit> WhenActivated(
    Action<CompositeDisposable> handler)
{
    // ... implementation details ...
}
```

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

### DryIoc Integration Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/DIContainerIntegrations.md

Configures the application to use ReactiveUI with DryIoc as the dependency injection container.

```csharp
using ReactiveUI.Avalonia.Splat;
using DryIoc;

AppBuilder.Configure<App>()
    .UsePlatformDetect()
    .UseReactiveUIWithDryIoc(
        containerConfig: container =>
        {
            container.Register<MainViewModel>(Reuse.Singleton);
            container.Register<MainView>(Reuse.Singleton);
        },
        withReactiveUIBuilder: rxui =>
        {
            // Optional ReactiveUI customizations
        })
    .RegisterReactiveUIViewsFromEntryAssembly();
```

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

### Complete Usage Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AutoSuspendHelper.md

Demonstrates how to integrate AutoSuspendHelper into an Avalonia application's App class to manage suspension and state persistence.

```csharp
using Avalonia;
using Avalonia.Controls.ApplicationLifetimes;
using ReactiveUI.Avalonia;
using System.Reactive;

public partial class App : Application
{
    private AutoSuspendHelper? _suspendHelper;

    public override void Initialize()
    {
        AvaloniaXamlLoader.Load(this);
    }

    public override void OnFrameworkInitializationCompleted()
    {
        // Set up suspension helper
        if (ApplicationLifetime is IControlledApplicationLifetime lifetime)
        {
            _suspendHelper = new AutoSuspendHelper(lifetime);

            // Wire up state persistence
            RxSuspension.SuspensionHost.ShouldPersistState
                .Subscribe(async disposable =>
                {
                    try
                    {
                        await SaveApplicationStateAsync();
                        Debug.WriteLine("Application state saved.");
                    }
                    finally
                    {
                        disposable.Dispose();
                    }
                });

            // Signal that framework initialization is complete
            _suspendHelper.OnFrameworkInitializationCompleted();
        }

        base.OnFrameworkInitializationCompleted();
    }

    protected override void Cleanup()
    {
        _suspendHelper?.Dispose();
        base.Cleanup();
    }

    private async Task SaveApplicationStateAsync()
    {
        // Implement state persistence
        var state = new { /* ... */ };
        var json = JsonConvert.SerializeObject(state);
        await File.WriteAllTextAsync("app-state.json", json);
    }
}
```

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

### Enable Logging

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Enables logging for ReactiveUI and Splat.

```csharp
.UseReactiveUI(rxui =>
{
    rxui.WithRegistration(splat =>
    {
        // Splat logging is already wired
        // Use this.Log() in any class implementing IEnableLogger
    });
})
```

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

### State Persistence on Exit Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AutoSuspendHelper.md

Example of subscribing to ShouldPersistState to save application state.

```csharp
RxSuspension.SuspensionHost.ShouldPersistState
    .Subscribe(async disposable =>
    {
        try
        {
            // Save application state to disk
            await SaveAppStateAsync();
        }
        finally
        {
            disposable.Dispose(); // Signal completion
        }
    });
```

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

### GetSubject (Typed) Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaObjectReactiveExtensions.md

Example usage of GetSubject (Typed) for bidirectional binding to an Avalonia property.

```csharp
var textBlock = new TextBlock();
var textProperty = TextBlock.TextProperty;
var subject = textBlock.GetSubject<string?>(textProperty);

// Bidirectional binding
subject
    .Select(text => text?.ToUpper())
    .Subscribe(upperText => Debug.WriteLine($"Upper: {upperText}"));

// Setting value through subject updates property
subject.OnNext("hello");  // TextBlock.Text becomes "hello"
```

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

### XmlnsDefinition Attribute Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/types.md

Example of using XmlnsDefinition attribute for XAML namespace mapping.

```xml
xmlns:rxui="using:ReactiveUI.Avalonia"
```

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

### GetSubject (Untyped) Example

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaObjectReactiveExtensions.md

Example usage of GetSubject (Untyped) to subscribe to changes and push new values to an Avalonia property.

```csharp
var button = new Button();
var subject = button.GetSubject(Button.ContentProperty);

// Subscribe to changes
subject.Subscribe(value => Debug.WriteLine($"Content: {value}"));

// Push new values
subject.OnNext("Clicked!");
```

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

### Service Registration After Initialization

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Registers a service using a factory function and then resolves it.

```csharp
var locator = Splat.Locator.CurrentMutable;
locator.Register<IDataService>(() => new DataService());

// Resolve
var service = Splat.Locator.Current.GetService<IDataService>();
```

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

### Usage in XAML

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ReactiveControls.md

Example of how to use ReactiveUserControl in XAML.

```xml
<rxui:ReactiveUserControl x:Class="MyApp.Views.MainView"
                          xmlns="https://github.com/avaloniaui"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:rxui="using:ReactiveUI.Avalonia">
    <Grid>
        <TextBlock x:Name="GreetingTextBlock" FontSize="24"/>
    </Grid>
</rxui:ReactiveUserControl>
```

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

### Custom Service Registration After Initialization

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Registering additional services with the service locator after framework initialization.

```csharp
public partial class App : Application
{
    public override void OnFrameworkInitializationCompleted()
    {
        var locator = Splat.Locator.CurrentMutable;
        
        // Register additional services
        locator.Register<IDataService>(() => new DataService());
        
        base.OnFrameworkInitializationCompleted();
    }
}
```

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

### Unsubscribe Properly

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Demonstrates proper unsubscription using WhenActivated, ensuring that subscriptions are automatically disposed of when the view deactivates.

```csharp
this.WhenActivated(disposables =>
{
    subscription.DisposeWith(disposables);
    // Automatically disposed when view deactivates
});
```

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

### One-Way Binding

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Example of a one-way binding from a ViewModel property to a View property.

```csharp
this.OneWayBind(ViewModel, vm => vm.Text, v => v.TextBlock.Text);
```

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

### RoutedViewHost Constructor

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

Initializes a new instance of the RoutedViewHost class and sets up reactive navigation between view models and views.

```csharp
public RoutedViewHost()
{
    // ... implementation details ...
}
```

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

### Constructor for ReactiveWindow<TViewModel>

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ReactiveControls.md

Initializes a new instance of the ReactiveWindow<TViewModel> class and sets up activation handling.

```csharp
public ReactiveWindow()
```

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

### Mocking ViewModel for View Testing

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/Architecture.md

An example of mocking a ViewModel to test the behavior of a View.

```csharp
var mockVm = new Mock<IMyViewModel>();
mockVm.SetupGet(x => x.MyProperty).Returns("TestValue");

var view = new MyView { ViewModel = mockVm.Object };

// Assert view behavior
```

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

### Custom Activation Strategy in Views

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/Architecture.md

Example of overriding activation behavior in a custom ReactiveControl.

```csharp
public class CustomReactiveControl<TViewModel> : ReactiveUserControl<TViewModel>
    where TViewModel : class
{
    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
    {
        base.OnPropertyChanged(change);
        if (change.Property == VisibleProperty)
        {
            // Custom activation/deactivation logic
        }
    }
}
```

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

### WithSuspensionHost

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Configure suspension system behavior within the UseReactiveUI configuration.

```csharp
.UseReactiveUI(rxui =>
{
    rxui.WithSuspensionHost<Unit>();
})
```

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

### Custom Binding Hook Implementation

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/Architecture.md

Example implementation of IPropertyBindingHook to intercept property bindings.

```csharp
public class CustomBindingHook : IPropertyBindingHook
{
    public bool ExecuteHook(
        object? source, object target,
        Func<IObservedChange<object, object>[]> getCurrentViewModelProperties,
        Func<IObservedChange<object, object>[]> getCurrentViewProperties,
        BindingDirection direction)
    {
        // Intercept, modify, or reject bindings
        return true;
    }
}
```

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

### Manual Assembly Scanning for Views

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/configuration.md

Manually specifying assemblies to scan for ReactiveUI views and ViewModels.

```csharp
.RegisterReactiveUIViews(
    typeof(MainView).Assembly,      // Views assembly
    typeof(MainViewModel).Assembly  // ViewModels assembly
)
```

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

### View Resolution Logging

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Logs generated by RoutedViewHost and ViewModelViewHost for view resolution, default content fallback, and contract usage. Look for specific messages in the output window.

```csharp
// RoutedViewHost and ViewModelViewHost log:
// - View resolution success/failure
// - Default content fallback
// - Contract usage

// Check output window for:
// - "Ready to show..."
// - "Couldn't find view for..."
// - "Falling back to default content"
```

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

### Binding Value Subject

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Gets the binding subject for a given Avalonia property.

```csharp
var subject = control.GetBindingSubject(Control.IsVisibleProperty);

subject
    .Where(v => v.HasValue)
    .Subscribe(v => Debug.WriteLine($"Visible: {v.Value}"));
```

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

### Avoid Memory Leaks

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/QuickReference.md

Illustrates the correct and incorrect ways to handle subscriptions to prevent memory leaks. Using WhenActivated ensures proper disposal.

```csharp
// Good: Uses WhenActivated
this.WhenActivated(disposables =>
{
    observable.Subscribe(...).DisposeWith(disposables);
});

// Bad: Memory leak
observable.Subscribe(...); // Never disposed
```

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

### Reactive Extensions Usage

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaScheduler.md

Examples of using AvaloniaScheduler with ObserveOn and SubscribeOn for marshaling operations to the UI thread.

```csharp
using System.Reactive;

// Use with ObserveOn to marshal operations to UI thread
observable
    .ObserveOn(AvaloniaScheduler.Instance)
    .Subscribe(value =>
    {
        // This lambda runs on the UI thread
        UIElement.Property = value;
    });

// Use with SubscribeOn for subscription on UI thread
observable
    .SubscribeOn(AvaloniaScheduler.Instance)
    .Subscribe(/* ... */);
```

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

### ViewModelViewHost Constructor

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/ViewHosts.md

The constructor for ViewModelViewHost.

```csharp
public ViewModelViewHost()
```

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

### Instance Property Usage

Source: https://github.com/reactiveui/reactiveui.avalonia/blob/main/_autodocs/api-reference/AvaloniaScheduler.md

Example usage of accessing the singleton instance of AvaloniaScheduler and using it with reactive operators.

```csharp
// Access the singleton instance
var scheduler = AvaloniaScheduler.Instance;

// Or use directly with reactive operators
observable.ObserveOn(AvaloniaScheduler.Instance);
```