### Install Avalonia.Markup.Declarative Templates

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/readme.md

Installs the project template for creating new Avalonia.Markup.Declarative projects.

```bash
dotnet new install Declarative.Avalonia.Templates
dotnet new avalonia-declarative -n MyApp
```

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

### Install Declarative.Avalonia.Templates

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/Templates/Declarative.Avalonia.Templates/README.md

Installs the Avalonia declarative UI project template using the .NET CLI.

```bash
dotnet new install Declarative.Avalonia.Templates
```

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

### View Initialization Examples

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/types.md

Demonstrates how to use ViewInitializationStrategy for lazy and immediate view initialization, and how to set the global default.

```csharp
// Use lazy initialization (default)
var lazyView = new MyView(); // Not initialized yet
var control = lazyView.Child; // Now initialized on first access

// Use immediate initialization
public class EagerView : ViewBase
{
    public EagerView() : base(ViewInitializationStrategy.Immediate)
    {
        // View is initialized immediately
    }
}

// Set global default
AppBuilder.Configure<Application>()
    .UseViewInitializationStrategy(ViewInitializationStrategy.Immediate);
```

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

### Legacy Tool Installation and Usage

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/GenerateMarkupExtensionsForAssemblyAttribute.md

Example of installing and using the legacy `avalonia-amd-gen` command-line tool. This approach is no longer required with the current source generator.

```bash
dotnet tool install avalonia-amd-gen
avalonia-amd-gen --project MyProject.csproj
```

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

### Minimal Avalonia App Setup

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

This snippet shows the most basic configuration for an Avalonia application. It sets up the application builder and starts the classic desktop lifetime.

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

    public static AppBuilder BuildAvaloniaApp()
    {
        return AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace();
    }
}
```

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

### ViewBase Usage Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Example of creating and manually initializing a custom view that inherits from ViewBase.

```csharp
public class MyView : ViewBase
{
    protected override object Build()
    {
        return new StackPanel()
            .Children(
                new TextBlock().Text("Hello"),
                new Button().Content("Click me")
            );
    }
}

// Usage
var view = new MyView();
view.Initialize(); // Manual initialization if needed
```

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

### Full Featured Avalonia App Setup with DI

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

This snippet demonstrates a comprehensive setup including dependency injection configuration, declarative markup, and hot reload. It's suitable for complex applications requiring service management.

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

    public static AppBuilder BuildAvaloniaApp()
    {
        // Configure dependency injection
        var services = new ServiceCollection()
            .AddSingleton<ILogger>(new ConsoleLogger())
            .AddSingleton<IRepository, Repository>()
            .AddSingleton<MainViewModel>()
            .AddSingleton<MainWindow>()
            .AddSingleton<SettingsView>()
            .BuildServiceProvider();

        return AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace()
            // Configure declarative markup
            .UseServiceProvider(services)
            .UseComponentControlFactory(type =>
                (Control)ActivatorUtilities.CreateInstance(services, type))
            .UseViewInitializationStrategy(ViewInitializationStrategy.Lazy)
            .UseHotReload(isDevelopment: true);
    }
}
```

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

### Example Implementation of ViewBase<TViewModel>

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Demonstrates how to subclass ViewBase<TViewModel> to create a CounterView. It initializes the view model in the constructor and implements the Build method to define the UI.

```csharp
public class CounterView : ViewBase<CounterViewModel>
{
    public CounterView() : base(new CounterViewModel()) { }

    protected override object Build(CounterViewModel vm)
    {
        return new StackPanel()
            .Children(
                new TextBlock()
                    .Text(vm, x => x.DisplayText),
                new Button()
                    .Content("Increment")
                    .OnClick(_ => vm.Increment())
            );
    }
}
```

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

### IReloadable Implementation Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/Interfaces.md

Example of implementing the IReloadable interface in a custom view. The ViewBase class provides a default implementation that clears the visual tree and reinitializes.

```csharp
public class MyView : ViewBase, IReloadable
{
    public void Reload()
    {
        // ViewBase provides implementation
        // Clears visual tree and calls Initialize()
    }
}
```

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

### ViewBase Build Method Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Abstract method that must be implemented by subclasses to return the root control or control hierarchy for the view.

```csharp
protected abstract object Build()

// Example implementation:
protected override object Build()
{
    return new StackPanel()
        .Children(
            new TextBlock().Text("Content")
        );
}
```

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

### Complete Avalonia Application Configuration Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/AppBuilderExtensions.md

Demonstrates setting up dependency injection and configuring the Avalonia AppBuilder with declarative markup extensions. This includes using `UseServiceProvider`, `UseComponentControlFactory`, `UseViewInitializationStrategy`, and `UseHotReload`.

```csharp
// Program.cs
using Microsoft.Extensions.DependencyInjection;
using Avalonia.Markup.Declarative;

public static class Program
{
    [STAThread]
    public static void Main(string[] args)
    {
        var app = BuildAvaloniaApp();
        app.StartWithClassicDesktopLifetime(args);
    }

    public static AppBuilder BuildAvaloniaApp()
    {
        // Set up dependency injection
        var services = new ServiceCollection()
            .AddSingleton<IAppService, AppService>()
            .AddSingleton<MainViewModel>()
            .AddSingleton<MainView>()
            .BuildServiceProvider();

        return AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace()
            // Configure declarative markup
            .UseServiceProvider(services)
            .UseComponentControlFactory(type =>
                (Control)ActivatorUtilities.CreateInstance(services, type))
            .UseViewInitializationStrategy(ViewInitializationStrategy.Lazy)
            .UseHotReload(true);
    }
}

// Usage in views
public class MainView : ViewBase<MainViewModel>
{
    public MainView() : base(new MainViewModel()) { }

    protected override object Build(MainViewModel vm)
    {
        return new StackPanel()
            .Children(
                new TextBlock().Text("Configured Application"),
                new Button().Content("Click me")
            );
    }
}
```

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

### IDeclarativeViewBase Usage Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/Interfaces.md

Example demonstrating how a custom view inherits from ViewBase and implicitly implements IDeclarativeViewBase. This enables the generation of markup extensions for the custom control.

```csharp
// Any ViewBase-derived class automatically implements this
public class MyCustomView : ViewBase
{
    protected override object Build() => new TextBlock();
}

// This automatically gets markup extensions generated:
// public static MyCustomView Foo(this MyCustomView control, string value) => ...
```

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

### ViewBase OnAfterInitialized Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Called after the view has been successfully initialized. Override for post-initialization setup.

```csharp
protected virtual void OnAfterInitialized()
```

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

### Basic View Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Demonstrates how to create a simple view with a text block and a button using Avalonia Markup Declarative. This is suitable for straightforward UI layouts.

```csharp
using Avalonia.Markup.Declarative;

public class HelloView : ViewBase
{
    protected override object Build()
    {
        return new StackPanel()
            .Children(
                new TextBlock()
                    .Text("Hello, World!"),
                new Button()
                    .Content("Click me")
                    .OnClick(_ => MessageBox.Show("Clicked!"))
            );
    }
}
```

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

### Handling Compiled Binding Setup Errors

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

This example demonstrates how ViewBuildingException is thrown when there are issues during compiled binding setup, such as a non-existent property or a type mismatch. The exception is thrown directly from the _setCompiledBinding method.

```csharp
new TextBox()
    ._setCompiledBinding(TextBox.TextProperty, viewModel, x => x.InvalidProperty)
    // ViewBuildingException: Property doesn't exist or type mismatch
```

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

### Application Setup

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Shows the essential code for setting up and running an Avalonia application, including service registration and lifetime management. This is the entry point for your Avalonia application.

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

    public static AppBuilder BuildAvaloniaApp()
    {
        var services = new ServiceCollection()
            .AddSingleton<MainViewModel>()
            .AddSingleton<MainWindow>()
            .BuildServiceProvider();

        return AppBuilder.Configure<Application>()
            .UsePlatformDetect()
            .LogToTrace()
            .UseServiceProvider(services)
            .UseComponentControlFactory(type =>
                (Control)ActivatorUtilities.CreateInstance(services, type))
            .UseHotReload(true);
    }
}
```

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

### Create New Avalonia Declarative App

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/Templates/Declarative.Avalonia.Templates/README.md

Creates a new Avalonia application named 'MyApp' using the installed declarative template.

```bash
dotnet new avalonia-declarative -n MyApp
```

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

### Using Source-Generated Factories

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactoryRegistry.md

Example of how to use ViewFactory.Create<T>() when control factories are automatically registered by the source generator. This is typically done in application startup code.

```csharp
// In Program.cs or startup code, source generation automatically registers:
// ViewFactoryRegistry.Register(() => new MyView());

// Usage:
var view = ViewFactory.Create<MyView>();
```

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

### AppBuilderExtensions.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Application setup extensions for Avalonia.Markup.Declarative, including service provider configuration, control factory registration, and hot reload enablement.

```APIDOC
## Application Setup Extensions

### Description
Methods for configuring the Avalonia application setup process. This includes integrating dependency injection, registering custom control factories, setting view initialization strategies, and enabling hot reload.

### Methods
- **Service Provider Configuration**: Integrate with `IServiceProvider` for dependency injection.
- **Control Factory Registration**: Register custom factories for creating controls.
- **View Initialization Strategy**: Configure how views are initialized.
- **Hot Reload Enablement**: Activate hot reload functionality for .NET 6.0+.
```

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

### ViewBase BuildStyles Method Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Optionally returns a StyleGroup for view-local styles. Override to define custom styles for controls within the view.

```csharp
protected virtual StyleGroup? BuildStyles()
{
    return new StyleGroup()
        .Add(new Style<TextBlock>()
            .Selector(s => s.OfType<TextBlock>())
            .Setter(TextBlock.ForegroundProperty, Brushes.Blue));
}
```

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

### ViewBase OnCreated Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Called before the view is initialized and built. Override this method to perform setup tasks before child controls are created.

```csharp
protected virtual void OnCreated()
{
    // Initialize resources, subscriptions, etc.
}
```

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

### Declarative Component Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/readme.md

Demonstrates a self-contained declarative component using C# for Avalonia UI. It includes a reactive state management using CommunityToolkit.Mvvm.

```csharp
using Avalonia.Data;
using CommunityToolkit.Mvvm.ComponentModel;

public class CounterComponent() : ViewBase<CounterComponent.State>(new State())
{
    public sealed partial class State : ObservableObject
    {
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(CounterLabel))]
        public partial decimal? Counter { get; set; } = 0;

        [ObservableProperty]
        public partial string StatusText { get; set; } = "Hello world";

        public string CounterLabel => $"Counter: {Counter}";
    }

    protected override object Build(State state) =>
        new StackPanel()
            .Children(
                new TextBlock()
                    .Text(state, x => x.StatusText),
                new TextBlock()
                    .Text(state, x => x.CounterLabel),
                new NumericUpDown()
                    .Value(state, x => x.Counter, BindingMode.TwoWay),
                new Button()
                    .Content("Increment")
                    .OnClick(_ => state.Counter++)
            );
}
```

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

### MVVM View Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Illustrates creating a view that follows the MVVM pattern, binding UI elements to a ViewModel for data and command interactions. Use this for more complex applications requiring separation of concerns.

```csharp
using Avalonia.Markup.Declarative;
using Avalonia.Data;

public class CounterView : ViewBase<CounterViewModel>
{
    public CounterView() : base(new CounterViewModel()) { }

    protected override object Build(CounterViewModel vm)
    {
        return new StackPanel()
            .Children(
                new TextBlock()
                    .Text(vm, x => x.Count),
                new Button()
                    .Content("Increment")
                    .OnClick(_ => vm.Increment()),
                new NumericUpDown()
                    .Value(vm, x => x.Count, BindingMode.TwoWay)
            );
    }
}
```

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

### ViewFactory Usage Flow

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactoryRegistry.md

Illustrates the sequence of checks performed by ViewFactory.Create<T>() to instantiate a control, starting from component control factories to fallback mechanisms.

```text
User Code
    ↓
ViewFactory.Create<T>()
    ↓
1. Check AppBuilderExtensions.ComponentControlFactory
2. Check ViewFactoryRegistry.TryCreate<T>()
3. Fall back to Activator.CreateInstance<T>()
    ↓
Control Instance
```

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

### OnAfterInitialized() Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

The protected virtual OnAfterInitialized() method is called after the view has been successfully initialized. It can be overridden to perform post-initialization setup.

```APIDOC
## OnAfterInitialized()

```csharp
protected virtual void OnAfterInitialized()
```

Called after the view has been successfully initialized. Override to perform post-initialization setup.
```

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

### Style Configuration via BuildStyles

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Define styles for views by overriding the BuildStyles method. This example demonstrates styling a TextBlock with specific foreground and font size.

```csharp
public class StyledView : ViewBase
{
    protected override object Build() => 
        new TextBlock().Text("Styled content");

    protected override StyleGroup? BuildStyles()
    {
        return new StyleGroup()
            .Add(new Style<TextBlock>()
                .Setter(TextBlock.ForegroundProperty, Brushes.Blue)
                .Setter(TextBlock.FontSizeProperty, 14));
    }
}
```

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

### Internal DefaultViewInitializationStrategy Property

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/AppBuilderExtensions.md

Gets the default view initialization strategy set via `UseViewInitializationStrategy()`. Used by `ViewBase` constructors.

```csharp
internal static ViewInitializationStrategy DefaultViewInitializationStrategy { get; }
```

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

### Catching ViewBuildingException

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Example of how to catch and handle ViewBuildingException. The exception message includes file path and line number, and the inner exception provides the root cause.

```csharp
try
{
    var view = new MyView();
}
catch (ViewBuildingException ex)
{
    // ex.Message includes file path and line number
    // ex.InnerException is the root cause
    Console.WriteLine($"Build failed: {ex.Message}");
}
```

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

### Handling Binary Compatibility Issues with ViewBuildingException

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

This example illustrates how ViewBuildingException is used to signal binary compatibility issues, often due to Avalonia version mismatches or dependency problems. The exception message provides specific context about the compatibility problem.

```csharp
// ViewBuildingException with special message about binary compatibility
// Usually indicates: Avalonia version mismatch or dependency issue
```

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

### Generated Code Example by Source Generator

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactoryRegistry.md

This code demonstrates the structure of C# code automatically generated by the source generator for registering custom control factories and fluent extension methods.

```csharp
// This is what the source generator produces in your project:
[module: CompilerFeature("RefStructs")]

namespace GeneratedMarkupExtensions
{
    public static class MarkupExtensions
    {
        // Generated when a custom control needs factory registration
        static MarkupExtensions()
        {
            ViewFactoryRegistry.Register(() => new MyCustomControl());
        }

        // Generated fluent extension methods for MyCustomControl
        public static MyCustomControl Text(this MyCustomControl control, string value) => 
            control._set(() => { /* ... */ });
    }
}
```

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

### OnCreated() Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

The protected virtual OnCreated() method is called before initialization and building of the UI. It can be overridden to run setup code before child controls are created.

```APIDOC
## OnCreated()

```csharp
protected virtual void OnCreated()
```

Called before initialization and building of the UI. Override to run setup code before child controls are created.

**Example:**
```csharp
protected override void OnCreated()
{
    // Initialize resources, subscriptions, etc.
}
```
```

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

### Using GenerateMarkupExtensionsForAssembly with a Custom Library

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/GenerateMarkupExtensionsForAssemblyAttribute.md

Generate fluent extensions for custom controls defined in a separate project. This example shows how to apply the attribute to ProjectA.Controls.AdvancedPanel and then use the generated extensions in ProjectB.

```csharp
// ProjectA: Defines custom controls
namespace ProjectA.Controls
{
    public class AdvancedPanel : Panel
    {
        public static readonly StyledProperty<double> SpacingProperty =
            AvaloniaProperty.Register<AdvancedPanel, double>(nameof(Spacing));

        public double Spacing { /* ... */ }
    }

    public class AdvancedButton : Button
    {
        // Custom properties and logic
    }
}

// ProjectB: Uses ProjectA controls declaratively
using Avalonia.Markup.Declarative;
using ProjectA.Controls;

[assembly: GenerateMarkupExtensionsForAssembly(typeof(AdvancedPanel))]

public class MyView : ViewBase
{
    protected override object Build()
    {
        // Generated extensions for AdvancedPanel and AdvancedButton
        return new AdvancedPanel()
            .Children(
                new AdvancedButton()
                    .Content("Custom Control")
            );
    }
}
```

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

### Create and apply an untyped selector to a style

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/StylePropertyExtensions.md

Use this method to create an untyped style and apply a selector. The selector function receives null as the starting selector.

```csharp
var style = new Style()
    .Selector(s => new Selector().OfType<TextBlock>().Class("highlight"))
    .Setter(TextBlock.ForegroundProperty, Brushes.Red);
```

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

### Equivalent XAML for MVVM View

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/readme.md

This XAML represents the same view structure and data binding as the C# declarative example, using Avalonia's XAML syntax with compiled bindings.

```xml
<UserControl
    xmlns="https://github.com/avaloniaui"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:vm="using:MyApp.ViewModels"
    x:Class="MyApp.MainView"
    x:DataType="vm:MainViewModel">
    <StackPanel>
        <TextBox Text="{CompiledBinding Message, Mode=TwoWay}" />
        <TextBlock Text="{CompiledBinding Message}" />
        <Button Content="Reset"
                Click="ResetClick" />
    </StackPanel>
</UserControl>
```

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

### Preventing Infinite Loops in View Initialization

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Avoid infinite recursion in the `Build` method by ensuring it returns controls rather than creating new view instances. This example contrasts the incorrect recursive approach with the correct control-returning method.

```csharp
// WRONG - Build() creates new instance, causing recursion
protected override object Build()
{
    return new MyView(); // Infinite recursion!
}

// RIGHT - Build() returns controls, not views
protected override object Build()
{
    return new StackPanel()
        .Children(
            new TextBlock().Text("Content")
        );
}
```

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

### Configure DI Once at Startup

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Set up the service provider once during application startup. Ensure the service provider is built before configuring the AppBuilder.

```csharp
var services = BuildServices();
AppBuilder.Configure<App>()
    .UseServiceProvider(services);
```

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

### Building a Native Application Menu

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/NativeMenuExtensions.md

Demonstrates how to construct a complete native menu with File, Edit, and Help sections, including items with commands and keyboard shortcuts. This is useful for setting up the main application menu bar.

```csharp
public class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        BuildMenu();
    }

    private void BuildMenu()
    {
        var mainMenu = new NativeMenu()
            .Items(
                new NativeMenuItem { Header = "File" }
                    .Items(
                        new NativeMenuItem 
                        {
                            Header = "New",
                            Command = new RelayCommand(() => OnNewFile())
                        },
                        new NativeMenuItem 
                        {
                            Header = "Open",
                            Command = new RelayCommand(() => OnOpenFile())
                        },
                        new NativeMenuItemSeparator(),
                        new NativeMenuItem 
                        {
                            Header = "Exit",
                            Command = new RelayCommand(() => Close())
                        }
                    ),
                new NativeMenuItem { Header = "Edit" }
                    .Items(
                        new NativeMenuItem 
                        {
                            Header = "Undo",
                            KeyboardShortcut = new KeyGesture(Key.Z, KeyModifiers.Control)
                        },
                        new NativeMenuItem 
                        {
                            Header = "Redo",
                            KeyboardShortcut = new KeyGesture(Key.Y, KeyModifiers.Control)
                        }
                    ),
                new NativeMenuItem { Header = "Help" }
                    .Items(
                        new NativeMenuItem 
                        {
                            Header = "About",
                            Command = new RelayCommand(() => ShowAbout())
                        }
                    )
            );

        NativeMenu.SetMenu(this, mainMenu);
    }

    private void OnNewFile() { /* ... */ }
    private void OnOpenFile() { /* ... */ }
    private void ShowAbout() { /* ... */ }
}
```

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

### Selector (untyped)

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/StylePropertyExtensions.md

Creates and applies a selector to an untyped style. The selector function receives null as the starting selector.

```APIDOC
## Selector (untyped)

### Description
Creates and applies a selector to an untyped style. The selector function receives null as the starting selector.

### Method Signature
```csharp
public static Style Selector(
    this Style style,
    Func<Selector?, Selector> selector)
```

### Parameters
#### Method Parameters
- **style** (Style) - Required - The style to configure.
- **selector** (Func<Selector?, Selector>) - Required - Function that creates the selector chain.

### Return
Style - The style for method chaining

### Example
```csharp
var style = new Style()
    .Selector(s => new Selector().OfType<TextBlock>().Class("highlight"))
    .Setter(TextBlock.ForegroundProperty, Brushes.Red);
```
```

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

### Basic Control Instantiation and Usage

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Demonstrates creating a simple control and using it within a view's build method. This is suitable for basic UI construction.

```csharp
// Create a simple control
var button = ViewFactory.Create<Button>();
button.Content = "Click me";

// Use in a view
public class MyView : ViewBase
{
    protected override object Build()
    {
        return new StackPanel()
            .Children(
                ViewFactory.Create<MyCustomControl>()
            );
    }
}
```

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

### Building and Setting a Native Menu

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/NativeMenuExtensions.md

Demonstrates how to build a native menu structure and attach it to the application's main window using `NativeMenu.SetMenu()`. This is typically done within the `Build()` method of a `ViewBase`.

```csharp
public class MainView : ViewBase
{
    protected override object Build()
    {
        var mainWindow = Application.Current?.MainWindow as Window;
        
        if (mainWindow != null)
        {
            NativeMenu.SetMenu(mainWindow, BuildMenu());
        }

        return new StackPanel()
            .Children(
                new TextBlock().Text("Application content")
            );
    }

    private NativeMenu BuildMenu()
    {
        return new NativeMenu()
            .Items(
                new NativeMenuItem { Header = "File" }
                    .Items(
                        new NativeMenuItem { Header = "Exit" }
                    )
            );
    }
}
```

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

### With

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ControlPropertyExtensions.md

Executes an action on the control and returns it for further chaining. Useful for complex initialization logic.

```APIDOC
## With

### Description
Executes an action on the control and returns it for further chaining. Useful for complex initialization logic.

### Method
Extension Method

### Parameters
#### Path Parameters
- **control** (TElement) - Required - The control.
- **process** (Action<TElement>) - Required - Action to execute on the control.

### Response
#### Success Response (200)
- **TElement** - The control for method chaining

### Request Example
```csharp
new TextBlock()
    .With(tb => {
        tb.Text = "Hello";
        tb.FontSize = 14;
    });
```
```

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

### Control Instantiation with Dependency Injection

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Shows how to set up and use dependency injection with ViewFactory. Dependencies are injected automatically when controls are created.

```csharp
// Setup in Program.cs
var services = new ServiceCollection()
    .AddSingleton<ILogger, ConsoleLogger>()
    .AddSingleton<MyViewModel>()
    .AddSingleton<MyView>()
    .BuildServiceProvider();

AppBuilder.Configure<Application>()
    .UseComponentControlFactory(type =>
        (Control)ActivatorUtilities.CreateInstance(services, type))
    .SetupWithLifetime(lifetime);

// Usage in code
public class MyView : ViewBase
{
    public MyView(ILogger logger)
    {
        // Dependencies are injected through the factory
    }

    protected override object Build()
    {
        return ViewFactory.Create<MyCustomControl>();
    }
}
```

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

### Use Lazy Initialization for Startup Performance

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Configure view initialization to be lazy to improve startup performance.

```csharp
.UseViewInitializationStrategy(ViewInitializationStrategy.Lazy)
```

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

### Application Entry Point Error Handling

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Implement try-catch blocks at the application's entry point to gracefully handle exceptions during application startup and view building. This allows for logging errors and showing user-friendly messages.

```csharp
public static void Main(string[] args)
{
    try
    {
        BuildAvaloniaApp()
            .StartWithClassicDesktopLifetime(args);
    }
    catch (ViewBuildingException ex)
    {
        LogError("View build failed", ex);
        ShowErrorDialog(ex.Message);
    }
    catch (Exception ex)
    {
        LogError("Application error", ex);
    }
}
```

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

### Internal ComponentControlFactory Property

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/AppBuilderExtensions.md

Gets the registered component control factory function set via `UseComponentControlFactory()`. Used by `ViewFactory.Create<T>()` for control instantiation.

```csharp
internal static Func<Type, Control>? ComponentControlFactory { get; }
```

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

### Internal ServiceProvider Property

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/AppBuilderExtensions.md

Gets the currently configured service provider set via `UseServiceProvider()`. For internal use by the view factory system.

```csharp
internal static IServiceProvider? ServiceProvider { get; }
```

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

### ViewFactory vs. Direct Instantiation

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Compares the usage of ViewFactory for creating views with DI versus direct instantiation. ViewFactory is recommended for DI scenarios.

```csharp
// Without ViewFactory (direct instantiation)
var view = new MyView();

// With ViewFactory (recommended for DI scenarios)
var view = ViewFactory.Create<MyView>();
```

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

### Registering and Using Custom Control Factories

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Illustrates registering a specific factory for a control type with ViewFactoryRegistry. This allows for custom instantiation logic without a full DI container.

```csharp
// Register a factory
ViewFactoryRegistry.Register(() => 
    new ComplexControl(new SpecialDependency()));

// Use it
var control = ViewFactory.Create<ComplexControl>();
```

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

### HotReloadManager.IsEnabled

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/HotReloadManager.md

Gets or sets whether hot reload is enabled globally. This property can be controlled via Activate() and Deactivate() methods, or configured via AppBuilderExtensions.UseHotReload().

```APIDOC
## HotReloadManager.IsEnabled

### Description
Gets or sets whether hot reload is enabled globally.

### Property
`public static bool IsEnabled { get; private set; }`

### Remarks
- Default value is `true`
- Can be controlled via `Activate()` and `Deactivate()` methods
- Can also be configured via `AppBuilderExtensions.UseHotReload()`

### Example
```csharp
if (HotReloadManager.IsEnabled)
{
    Console.WriteLine("Hot reload is active");
}
```
```

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

### Create Control Instance with ViewFactory

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/types.md

Use ViewFactory.Create to instantiate controls. It utilizes registered factories or a parameterless constructor.

```csharp
public static TControl Create<TControl>() where TControl : Control
```

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

### GenerateMarkupExtensionsForAssembly Attribute Example

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/types.md

Use the GenerateMarkupExtensionsForAssembly attribute at the assembly level to enable fluent extensions for third-party controls. Specify a type from the target assembly as an anchor.

```csharp
[assembly: GenerateMarkupExtensionsForAssembly(typeof(CustomButton))]
[assembly: GenerateMarkupExtensionsForAssembly(typeof(RoutedViewHost))]
```

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

### Using ViewBase in Avalonia Markup Declarative

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/types.md

Demonstrates how to use the ViewBase class from the Avalonia.Markup.Declarative namespace. Ensure the necessary using directive is present.

```csharp
using Avalonia.Markup.Declarative;

// Now available:
public class MyView : ViewBase<MyViewModel> { }
```

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

### ViewBase Initialize Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Manually initializes the view. This method calls OnCreated(), builds styles, and constructs the UI tree. It can throw ViewBuildingException on errors.

```csharp
public void Initialize()
```

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

### Correcting Binding to Non-Existent Property

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Ensure that the property name used in `_setCompiledBinding` actually exists on the view model. This example shows the incorrect and correct usage.

```csharp
// WRONG - property doesn't exist
new TextBlock()
    ._setCompiledBinding(TextBlock.TextProperty, vm, x => x.NonExistentProperty);

// RIGHT - correct property name
new TextBlock()
    ._setCompiledBinding(TextBlock.TextProperty, vm, x => x.DisplayText);
```

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

### ViewBase.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Core view base classes and initialization. Includes `ViewBase`, `ViewBase<TViewModel>`, `ViewBuildingException`, and `ViewInitializationStrategy`.

```APIDOC
## ViewBase Classes and Initialization

### Description
Core base classes for creating declarative views in Avalonia.Markup.Declarative, including support for MVVM patterns and exception handling during view building.

### Classes
- **`ViewBase`**: Base class for all declarative views.
- **`ViewBase<TViewModel>`**: Generic base class for MVVM patterns.

### Exceptions
- **`ViewBuildingException`**: Exception thrown for view build failures.

### Enums
- **`ViewInitializationStrategy`**: Enum defining view initialization strategies.
```

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

### ViewBase Constructor Configuration

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Configure view initialization strategy using the ViewBase constructor. Supports lazy initialization (default) or explicit strategy.

```csharp
public class MyView : ViewBase
{
    // Lazy initialization (default)
    public MyView()
    {
    }

    // Or explicit strategy
    public MyView() : base(ViewInitializationStrategy.Lazy)
    {
    }

    protected override object Build() => new TextBlock();
}
```

```csharp
public class MyViewTyped : ViewBase<MyViewModel>
{
    // With view model injection and lazy init
    public MyViewTyped() : base(new MyViewModel())
    {
    }

    protected override object Build(MyViewModel vm) => new TextBlock();
}
```

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

### Resolving Version Mismatch Errors

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Version mismatches between Avalonia and its dependencies can cause `MissingMethodException` or similar errors. This example shows how to update packages using the `dotnet add package` command.

```bash
# Update all packages to compatible versions
dotnet add package Avalonia --version 11.0.0
dotnet add package ExternalPackage --version X.Y.Z

# OR check package compatibility in:
# - ExternalPackage documentation
# - Project file (*.csproj)
# - NuGet website
```

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

### View Lifecycle Hooks for Configuration

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Utilize optional lifecycle methods like OnCreated, OnAfterInitialized, and OnBeforeReload for view configuration and state management during initialization and hot reload.

```csharp
public class ConfiguredView : ViewBase
{
    // Called before Build() during initialization
    protected override void OnCreated()
    {
        // Initialize resources, subscriptions, etc.
    }

    // Called after successful initialization
    protected override void OnAfterInitialized()
    {
        // Perform post-init setup
    }

    // Called before hot reload
    protected override void OnBeforeReload()
    {
        // Save state, clean up resources
    }

    protected override object Build() => new TextBlock();
}
```

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

### Validate Configuration Early

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Catch and handle potential configuration errors, such as ViewBuildingException, early in the application startup process.

```csharp
try
{
    BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
}
catch (ViewBuildingException ex)
{
    // Handle configuration errors
}
```

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

### Set View Initialization Strategy

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Sets the default initialization strategy for all views. Choose between Lazy initialization for faster startup or Immediate initialization for predictable behavior.

```csharp
// Global setting
AppBuilder.Configure<Application>()
    .UseViewInitializationStrategy(ViewInitializationStrategy.Immediate);

// Individual view override
public class MyView : ViewBase
{
    public MyView() : base(ViewInitializationStrategy.Lazy)
    {
        // This view uses Lazy despite global Immediate setting
    }

    protected override object Build() => new TextBlock();
}
```

```csharp
// For fast startup
AppBuilder.Configure<Application>()
    .UseViewInitializationStrategy(ViewInitializationStrategy.Lazy);

// For predictable behavior (all views ready)
AppBuilder.Configure<Application>()
    .UseViewInitializationStrategy(ViewInitializationStrategy.Immediate);
```

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

### Execute Action on Control with 'With'

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ControlPropertyExtensions.md

Use the 'With' method to perform complex initialization logic on a control by executing an action. It returns the control for further chaining.

```csharp
public static TElement With<TElement>(
    this TElement control,
    Action<TElement> process)
```

```csharp
new TextBlock()
    .With(tb => {
        tb.Text = "Hello";
        tb.FontSize = 14;
    });
```
```

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

### _addSetterCompiledBinding (DataContext-relative)

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/StylePropertyExtensions.md

Adds a style setter using a compiled binding with the source determined at runtime from the element's DataContext. This overload is for internal use and offers simplified binding setup.

```APIDOC
## _addSetterCompiledBinding (DataContext-relative)

### Description
Adds a style setter using a compiled binding with the source determined at runtime from the element's DataContext.

### Method Signature
```csharp
public static Style<TElement> _addSetterCompiledBinding<TElement, TViewModel, TValue>(this Style<TElement> style, AvaloniaProperty avaloniaProperty, Expression<Func<TViewModel, TValue>> getter, BindingMode? bindingMode = null, IValueConverter? converter = null)
where TElement : StyledElement
```

### Parameters
#### Path Parameters
- **style** (Style<TElement>) - Required - The style to configure.
- **avaloniaProperty** (AvaloniaProperty) - Required - The property to set.
- **getter** (Expression<Func<TViewModel, TValue>>) - Required - Expression selecting the source property.
- **bindingMode** (BindingMode?) - Optional - The binding mode.
- **converter** (IValueConverter?) - Optional - Optional value converter.

### Return
Style<TElement> - The style for method chaining

### Example
```csharp
var style = new Style<TextBlock>()
    ._addSetterCompiledBinding<TextBlock, MyViewModel, Brush>(
        TextBlock.ForegroundProperty,
        x => x.TextColor);
```
```

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

### ViewBase<TViewModel> Build Method Signature

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Declares the abstract Build method that must be implemented by subclasses. It takes a strongly-typed view model and returns the UI object hierarchy.

```csharp
protected abstract object Build(TViewModel vm)
```

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

### Checking Exception Stack Trace

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Access the StackTrace property of a ViewBuildingException to get detailed information about the exact location in the code where the error occurred. This includes file paths and line numbers within the Build() method or extension methods.

```csharp
catch (ViewBuildingException ex)
{
    Console.WriteLine(ex.StackTrace);
    // Shows exact line in Build() or extension method where error occurred
}
```

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

### Configure Grid Columns and Rows

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Define column and row sizes for a Grid using string definitions or RowDefinitions/ColumnDefinitions objects.

```csharp
// String definitions
new Grid()
    .Cols("Auto,*,Auto")
    .Rows("*", "Auto", "*");

// Using objects
new Grid()
    .Cols(new ColumnDefinitions { "Auto", "*", "Auto" })
    .Rows(new RowDefinitions { "*", "Auto", "*" });
```

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

### Add Compiled Binding Setter with Explicit Source

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/StylePropertyExtensions.md

Adds a style setter using a compiled binding with an explicit source object. Use when the binding source is known and provided directly. Exceptions may occur if binding setup fails.

```csharp
public static Style<TElement> _addSetterCompiledBinding<TElement, TViewModel, TValue>(
    this Style<TElement> style,
    AvaloniaProperty avaloniaProperty,
    TViewModel source,
    Expression<Func<TViewModel, TValue>> getter,
    BindingMode? bindingMode = null,
    IValueConverter? converter = null)
    where TElement : StyledElement
```

```csharp
var viewModel = new MyViewModel();

var style = new Style<TextBlock>()
    ._addSetterCompiledBinding(
        TextBlock.ForegroundProperty,
        viewModel,
        x => x.TextColor,
        BindingMode.OneWay);
```

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

### Configure View Initialization Strategy

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/AppBuilderExtensions.md

Sets the default view initialization strategy for the application. Use Lazy for initialization on first access or Immediate for initialization in the constructor. Individual views can override this setting.

```csharp
public static AppBuilder UseViewInitializationStrategy(
    this AppBuilder appBuilder,
    ViewInitializationStrategy strategy)
```

```csharp
AppBuilder.Configure<Application>()
    .UseViewInitializationStrategy(ViewInitializationStrategy.Immediate)
    .SetupWithLifetime(lifetime);

// All views will now initialize immediately unless overridden
public class MyView : ViewBase
{
    public MyView() : base(ViewInitializationStrategy.Lazy)
    {
        // This view overrides the global setting
    }

    protected override object Build() => new TextBlock().Text("Hi");
}
```

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

### Create a Control Instance

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Instantiates a control of the specified type. It uses registered factories or falls back to the parameterless constructor.

```csharp
public static TControl Create<TControl>() 
    where TControl : Control
```

```csharp
// Simple instantiation
var textBlock = ViewFactory.Create<TextBlock>();

// With dependency injection (if configured)
var myView = ViewFactory.Create<MyCustomView>();
```

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

### Initialize() Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

The Initialize() method manually initializes the view by calling OnCreated(), building styles, and constructing the UI tree. It can be called automatically or manually.

```APIDOC
## Initialize()

```csharp
public void Initialize()
```

Initializes the view by calling `OnCreated()`, building styles, and calling `Build()` to construct the UI tree. Called automatically based on `InitializationStrategy`, or manually if needed.

**Exceptions:**
| Exception | Condition |
|-----------|-----------|
| ViewBuildingException | Thrown if an error occurs during view building. Wraps inner exceptions with source file and line information. |

**Example:**
```csharp
public class MyView : ViewBase
{
    protected override object Build()
    {
        return new StackPanel()
            .Children(
                new TextBlock().Text("Hello"),
                new Button().Content("Click me")
            );
    }
}

// Usage
var view = new MyView();
view.Initialize(); // Manual initialization if needed
```
```

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

### Typed ViewBase Configuration

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Configure a strongly-typed view by inheriting from ViewBase<TViewModel> and injecting the view model in the constructor.

```csharp
public class TypedView : ViewBase<MyViewModel>
{
    // Constructor with view model injection
    public TypedView() : base(new MyViewModel())
    {
    }

    protected override object Build(MyViewModel vm) =>
        new TextBlock()
            .Text(vm, x => x.DisplayText);
}
```

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

### Build() Method

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

The abstract Build() method must be implemented by subclasses to return the root control or control hierarchy for the view.

```APIDOC
## Build()

```csharp
protected abstract object Build()
```

Abstract method that subclasses must implement. Returns the root control or control hierarchy for the view. Must be implemented by all subclasses.

**Example:**
```csharp
protected override object Build()
{
    return new StackPanel()
        .Children(
            new TextBlock().Text("Content")
        );
}
```
```

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

### Using GenerateMarkupExtensionsForAssembly with ReactiveUI

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/GenerateMarkupExtensionsForAssemblyAttribute.md

Apply the attribute to generate fluent extensions for controls like RoutedViewHost from the ReactiveUI.Avalonia library. This allows for a more concise and readable way to define UI elements in your application.

```csharp
// In your project file or GlobalUsings.cs
using Avalonia.Markup.Declarative;
using ReactiveUI.Avalonia;

[assembly: GenerateMarkupExtensionsForAssembly(typeof(RoutedViewHost))]

namespace MyApp;

public class MyView : ViewBase
{
    protected override object Build()
    {
        // RoutedViewHost now has fluent extensions available
        // (e.g., Content, Router, etc.)
        return new RoutedViewHost()
            .Router(MyRouter);
    }
}
```

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

### Custom Control Implementation of IReloadable and IDeclarativeViewBase

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/Interfaces.md

Shows how a custom control, not inheriting from ViewBase, can implement IReloadable and IDeclarativeViewBase to participate in the declarative system and hot reload.

```csharp
public class CustomControl : Decorator, IReloadable, IDeclarativeViewBase
{
    public void Reload()
    {
        // Implement reload logic
        Children.Clear();
        BuildUI();
    }

    private void BuildUI()
    {
        // Rebuild content
    }
}
```

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

### ComponentBase.New to ViewFactory.Create for View Composition

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/docs/avalonia-12-release-notes.md

Replaces `ComponentBase.New<T>()` with `ViewFactory.Create<T>()` for composing views. This change aligns with the new declarative view creation patterns and supports dependency injection.

```csharp
protected override object Build() =>
    ComponentBase.New<CounterComponent>();
```

```csharp
protected override object Build() =>
    ViewFactory.Create<CounterComponent>();
```

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

### Manual Control Registration

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactoryRegistry.md

Demonstrates manual registration of a control factory with ViewFactoryRegistry, including custom initialization logic. This is useful for special cases.

```csharp
// Manual registration for special cases:
ViewFactoryRegistry.Register(() =>
{
    var control = new ComplexControl();
    control.Initialize(); // Special initialization
    return control;
});

// Later:
var instance = ViewFactory.Create<ComplexControl>();
```

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

### Generic ViewBase Configuration

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/configuration.md

Configure a generic view by inheriting from ViewBase and setting the DataContext within the Build method.

```csharp
public class GenericView : ViewBase
{
    protected override object Build()
    {
        return new StackPanel()
            .DataContext(new MyViewModel(), out var vm)
            .Children(
                new TextBlock()
                    .Text(vm, x => x.DisplayText)
            );
    }
}
```

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

### ViewBase<TViewModel> Constructors

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

Defines protected constructors for ViewBase<TViewModel>. The first takes a strongly-typed view model, initializing the view immediately. The second is a parameterless constructor for lazy initialization.

```csharp
protected ViewBase(TViewModel viewModel)
protected ViewBase()
```

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

### NativeMenuExtensions.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Provides fluent API extensions for constructing native menus declaratively.

```APIDOC
## Native Menu Support

### Description
Offers fluent extension methods to declaratively define and build native menus within Avalonia applications.

### Features
- **Fluent Menu Construction**: Define menu items, submenus, and their properties using a chainable syntax.
```

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

### ViewFactory Fallback to ViewFactoryRegistry

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactory.md

Demonstrates how ViewFactory uses the ViewFactoryRegistry if no global factory is configured. This is useful for source-generated control registrations.

```csharp
// Source-generated code registers factories here
ViewFactoryRegistry.Register(() => new GeneratedControl());

// ViewFactory finds it
var control = ViewFactory.Create<GeneratedControl>();
```

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

### Unit Test for View Building

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

Write unit tests to verify that views build without errors by instantiating the view with a prepared view model. This test will throw an exception if the view building process fails.

```csharp
[TestMethod]
public void MyView_ShouldBuildWithoutError()
{
    // Arrange
    var vm = new MyViewModel { Data = "Test" };
    
    // Act & Assert
    var view = new MyView(vm); // Throws if build fails
    Assert.IsNotNull(view.Child);
}
```

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

### Specific Handling of ViewBuildingException in Main Application Loop

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/errors.md

This code demonstrates specific error handling for ViewBuildingException within the main application startup. It logs detailed error messages, including the root cause, and exits the application with an error code.

```csharp
public static void Main(string[] args)
{
    try
    {
        var app = BuildAvaloniaApp();
        app.StartWithClassicDesktopLifetime(args);
    }
    catch (ViewBuildingException ex)
    {
        Console.Error.WriteLine("View build error:");
        Console.Error.WriteLine($"  Message: {ex.Message}");
        Console.Error.WriteLine($"  Root cause: {ex.InnerException?.GetType().Name}");
        Console.Error.WriteLine($"  Details: {ex.InnerException?.Message}");
        
        // Log to file, show error dialog, etc.
        Environment.Exit(1);
    }
}
```

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

### ViewBase Constructors

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewBase.md

ViewBase offers two constructors: a default protected constructor and one that accepts a ViewInitializationStrategy.

```APIDOC
## Constructors

```csharp
protected ViewBase()
protected ViewBase(ViewInitializationStrategy initializationStrategy)
```

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| initializationStrategy | ViewInitializationStrategy | No | AppBuilderExtensions.DefaultViewInitializationStrategy | Determines when the view will be initialized |
```

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

### ViewFactory.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Control factory for instantiating controls, with integration for DI and factory registry.

```APIDOC
## View Factory

### Description
Provides a mechanism for creating Avalonia control instances declaratively. It integrates with dependency injection and the runtime factory registry for flexible control instantiation.

### Methods
- **`ViewFactory.Create<T>()`**: Instantiates a control of type `T`.
```

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

### ControlPropertyExtensions.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Fluent control configuration methods, including compiled bindings, data context, grid positioning, children management, styling, and action execution.

```APIDOC
## Fluent Control Configuration

### Description
Provides a fluent API for configuring Avalonia controls declaratively. This includes setting properties with compiled bindings, managing layout, handling data contexts, and executing actions.

### Features
- **Compiled Bindings**: Methods for setting up bindings with automatic type conversion.
- **Data Context**: Configuration for the data context of controls.
- **Layout**: Methods for grid positioning and spanning.
- **Children Management**: Adding and managing child elements.
- **Item Templates**: Configuration for `ItemsControl` and similar.
- **Styling**: Binding CSS classes and applying styles.
- **Actions**: Fluent execution of actions.
```

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

### Thread-Safe Registration and Creation

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/api-reference/ViewFactoryRegistry.md

Demonstrates concurrent registration and creation of controls from multiple threads using the ViewFactoryRegistry. This is safe due to the internal use of ConcurrentDictionary.

```csharp
Task.Run(() => ViewFactoryRegistry.Register(() => new ControlA()));
Task.Run(() => ViewFactoryRegistry.Register(() => new ControlB()));
Task.Run(() => ViewFactory.Create<ControlA>());
```

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

### StylePropertyExtensions.md

Source: https://github.com/avaloniaui/avalonia.markup.declarative/blob/master/_autodocs/README.md

Configuration for styles, including selectors, property setters with compiled bindings, and grid helpers.

```APIDOC
## Style Configuration

### Description
Enables declarative configuration of styles for Avalonia UI elements. This includes defining selectors, setting properties with compiled bindings, and utilizing grid layout helpers within styles.

### Features
- **Selector Configuration**: Defining conditions for style application.
- **Property Setters**: Setting control properties, supporting compiled bindings.
- **Grid Helpers**: Utility methods for grid layout within styles.
```