### BenchmarkDotNet Configuration and Results

Source: https://github.com/nventive/chinook.dynamicmvvm/wiki/Benchmarks-1.2.2

This snippet details the BenchmarkDotNet setup and the resulting performance metrics for the Chinook.DynamicMVVM project. It includes environment information, job configurations, and detailed performance data for various methods, such as ViewModel creation, property access, and disposal.

```text
BenchmarkDotNet v0.13.11, Windows 10 (10.0.19045.3324/22H2/2022Update)
Intel Core i7-10850H CPU 2.70GHz, 1 CPU, 12 logical and 6 physical cores
.NET SDK 7.0.304
  [Host]     : .NET 7.0.7 (7.0.723.27404), X64 RyuJIT AVX2
  DefaultJob : .NET 7.0.7 (7.0.723.27404), X64 RyuJIT AVX2
  Job-SMXNIU : .NET 7.0.7 (7.0.723.27404), X64 RyuJIT AVX2


| Method                              | Job        | InvocationCount | UnrollFactor | Mean      | Error     | StdDev    | Median    | Gen0   | Gen1   | Allocated |
|------------------------------------ |----------- |---------------- |------------- |----------:|----------:|----------:|----------:|-------:|-------:|----------:|
| CreateViewModel                     | DefaultJob | Default         | 16           |  2.278 μs | 0.0428 μs | 0.0856 μs |  2.284 μs | 0.3204 | 0.3166 |    2023 B |
| ReadProperty_Unresolved             | Job-SMXNIU | 1               | 1            |  2.754 μs | 0.0585 μs | 0.1630 μs |  2.800 μs |      - |      - |    1032 B |
| ReadProperty_Resolved               | Job-SMXNIU | 1               | 1            |  1.409 μs | 0.0322 μs | 0.0902 μs |  1.400 μs |      - |      - |     896 B |
| SetProperty_Unresolved              | Job-SMXNIU | 1               | 1            | 19.147 μs | 0.2796 μs | 0.2615 μs | 19.100 μs |      - |      - |    3016 B |
| SetProperty_Resolved                | Job-SMXNIU | 1               | 1            |  1.957 μs | 0.0428 μs | 0.1074 μs |  2.000 μs |      - |      - |     832 B |
| DisposeViewModel                    | Job-SMXNIU | 1               | 1            |  2.954 μs | 0.0614 μs | 0.0881 μs |  2.950 μs |      - |      - |     776 B |
| SetProperty_Unresolved_WithListener | Job-SMXNIU | 1               | 1            | 21.014 μs | 0.4206 μs | 1.1227 μs | 21.000 μs |      - |      - |    3256 B |
| SetProperty_Resolved_WithListener   | Job-SMXNIU | 1               | 1            |  3.031 μs | 0.0640 μs | 0.1051 μs |  3.000 μs |      - |      - |    1088 B |
| DisposeViewModel_WithListener       | Job-SMXNIU | 1               | 1            |  2.932 μs | 0.0722 μs | 0.2118 μs |  3.000 μs |      - |      - |     776 B |
```

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

### Create Basic ViewModel with DynamicMvvm

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates the creation of a basic ViewModel using `ViewModelBase` from the Chinook.DynamicMvvm library. It shows how to declare properties and commands using the `Get` and `GetCommand` methods for simplified MVVM implementation.

```csharp
using Chinook.DynamicMvvm;
// (...)
public class MainPageViewModel : ViewModelBase
{
  public string Content
  {
    get => this.Get(initialValue: string.Empty);
    set => this.Set(value);
  }

  public IDynamicCommand Submit => this.GetCommand(() =>
  {
    Result = Content;
  });

  public string Result
  {
    get => this.Get(initialValue: string.Empty);
    private set => this.Set(value);
  }
}
```

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

### Creating a Custom Delegating Command Strategy

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Provides an example of creating a custom delegating command strategy by inheriting from DelegatingCommandStrategy. This allows for custom logic in CanExecute and Execute methods, and shows how to create an extension method to easily apply the custom strategy.

```csharp
public class MyCustomCommandStrategy : DelegatingCommandStrategy
{
  public MyCustomCommandStrategy(IDynamicCommandStrategy innerStrategy) : base(innerStrategy)
  { }

  public override bool CanExecute(object parameter, IDynamicCommand command)
  {
    // Implement your custom logic here.
    return base.CanExecute(parameter, command);
  }

  public override async Task Execute(CancellationToken ct, object parameter, IDynamicCommand command)
  {
    // Implement your custom logic here.
    base.Execute(ct, parameter, command);
  }
}

public static class MyCustomCommandStrategyExtensions
{
  public static IDynamicCommandStrategy WithMyCustomStrategy(this IDynamicCommandStrategy strategy)
    => new MyCustomCommandStrategy(strategy);
}

// This will decorate the strategy with your custom one.
var myCommandWithMyCustomStrategy = myCommandStrategy.WithMyCustomStrategy();
```

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

### Register Validators in Service Provider in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Provides an example of how to register all validators from a specific assembly with the service provider, typically done during application startup.

```csharp
serviceCollection.AddValidatorsFromAssemblyContaining(typeof(App), ServiceLifetime.Singleton)
```

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

### Get and Observe DynamicProperty Value (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Illustrates using the 'GetAndObserve' extension method, which first emits the current value and then continues to emit subsequent changes to the DynamicProperty's value.

```csharp
myProperty.GetAndObserve().Subscribe(value =>
{
  // This will be called a first time with the initial value of the property.
  // It will then be called everytime the value of the property changes.
});
```

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

### Inheriting from ViewModelBase

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates the basic structure of creating a custom ViewModel by inheriting from the provided ViewModelBase class. This is the most common starting point for creating ViewModels in the Chinook Dynamic MVVM framework.

```csharp
public class MyViewModel : ViewModelBase
{
}
```

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

### Integrate Dispatcher for UI Thread Updates (UWP/Uno Legacy)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Provides an example of integrating a dispatcher for UI thread updates in UWP or Uno.UI (legacy) applications using `Chinook.DynamicMvvm`. It shows initializing `MainPageViewModel` with a `CoreDispatcherDispatcher` for proper `INotifyPropertyChanged` event handling on the main thread.

```csharp
public MainPage()
{
    this.InitializeComponent();
    DataContext = new MainPageViewModel()
    {
        Dispatcher = new CoreDispatcherDispatcher(this)
    };
}
```

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

### Using Dynamic Properties in ViewModel Constructor

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Provides an example of how to access the values of one-way and set the values of two-way dynamic properties within the ViewModel's constructor. This demonstrates the immediate usability of these properties after creation.

```csharp
public MyViewModel()
{
  // This will get the value of the IDynamicProperty named MyOneWayProperty
  var myValue = MyOneWayProperty;

  // This will set the value of the IDynamicProperty named MyTwoWayProperty
  MyTwoWayProperty = 20;
}
```

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

### Subscribe to DynamicCommand Execution Changes

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Shows how to subscribe to the IsExecutingChanged event of a DynamicCommand to be notified when the command starts or stops executing. An event handler method is provided.

```csharp
void OnIsExecutingChanged(object sender, EventArgs e)
{

}

myCommand.IsExecutingChanged += OnIsExecutingChanged;
```

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

### Get and Set DynamicProperty Value (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Shows how to access the current value of a DynamicProperty using its 'Value' property and how to update it, which triggers notifications to subscribers.

```csharp
var myValue = myProperty.Value;

myProperty.Value = 30;
```

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

### Observe Property Value with IObservable

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows how to use the Observe() and GetAndObserve() extension methods on an IDynamicProperty to get an IObservable<T> that emits values when the property changes. This integrates with System.Reactive.

```csharp
IObservable<string> observable;
observable = contentProperty.Observe(); // Gets an IObservable that yields when the value changes.
observable = contentProperty.GetAndObserve(); // Gets an IObservable that yields when the value changes and starts with the current value.
```

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

### Customize Command Declaration Behavior

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

This C# example shows how to customize the behavior of a specific command, `Submit`, at the declaration level. It uses a builder to apply the `SkipWhileExecuting` strategy, which prevents the command from executing if it's already in progress. This configuration is additive to any factory-level settings.

```csharp
public IDynamicCommand Submit => this.GetCommand(() =>
{
  Result = Content;
}, builder => builder
  .SkipWhileExecuting()
);
```

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

### Create and Execute a Basic DynamicCommand

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Demonstrates creating a DynamicCommand with a name and an action strategy, then executing it. The associated action method is called upon execution.

```csharp
var myCommandStrategy = new ActionCommandStrategy(ExecuteCommand);
var myCommand = new DynamicCommand("MyCommand", myCommandStrategy);

void ExecuteCommand()
{
  // Command execution logic here.
}

await myCommand.Execute();
```

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

### Configure IDynamicCommand Locally with Builder

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Shows how to apply local configurations, such as adding logging, to an IDynamicCommand using extension methods on the IDynamicCommandBuilder.

```csharp
var myFactory = new DynamicCommandBuilderFactory();
var myBuilder = myFactory.CreateFromAction("MyCommand", ExecuteCommand)
  .WithLogs();
var myCommand = myBuilder.Build();
private void ExecuteCommand() { }
```

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

### Create IDynamicCommand with Builder Factory

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Demonstrates the basic usage of IDynamicCommandBuilderFactory and IDynamicCommandBuilder to create a new IDynamicCommand from an action.

```csharp
var myFactory = new DynamicCommandBuilderFactory();
var myBuilder = myFactory.CreateFromAction("MyCommand", ExecuteCommand);
var myCommand = myBuilder.Build();
private void ExecuteCommand() { }
```

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

### Configure ServiceProvider with DynamicMvvm Factories

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Illustrates how to configure a `System.IServiceProvider` using `Microsoft.Extensions.DependencyInjection` and `Microsoft.Extensions.Hosting`. It registers the necessary `IDynamicCommandBuilderFactory` and `IDynamicPropertyFactory` implementations required by Chinook.DynamicMvvm.

```csharp
var serviceProvider = new HostBuilder()
  .ConfigureServices(serviceCollection => serviceCollection
    .AddSingleton<IDynamicCommandBuilderFactory, DynamicCommandBuilderFactory>()
    .AddSingleton<IDynamicPropertyFactory, DynamicPropertyFactory>()
  )
  .Build()
  .Services;
```

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

### Create Commands from Action

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Illustrates creating IDynamicCommand instances from Action delegates for commands without parameters, and Action<T> delegates for commands that accept a parameter. These are created using GetCommand().

```csharp
public IDynamicCommand SayHi => this.GetCommand(() =>
{
  Console.WriteLine("Hi");
});

public IDynamicCommand SaySomething => this.GetCommand<string>(parameter =>
{
  Console.WriteLine(parameter);
});
```

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

### Apply Default Configuration to Command Factory

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Illustrates how to set a default configuration for all commands created by an IDynamicCommandBuilderFactory, including executing on a background thread, catching errors, and adding logs.

```csharp
var myFactory = new DynamicCommandBuilderFactory(c => c
  .ExecuteOnBackgroundThread()
  .CatchErrors(HandleCommandError)
  .WithLogs()
));

var myBuilder = myFactory.CreateFromAction("MyCommand", ExecuteCommand);
var myCommand = myBuilder.Build();

private void ExecuteCommand() { }
```

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

### Configuring DynamicPropertyFactory

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Illustrates how to customize the creation of dynamic properties by registering a custom `IDynamicPropertyFactory` with the service collection. This allows for advanced property creation logic.

```csharp
private void ConfigureProperties(IServiceCollection services)
{
  services.AddSingleton<IDynamicPropertyFactory, DynamicPropertyFactory>();
}
```

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

### Create Commands from Async Methods

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates creating IDynamicCommand instances from asynchronous methods using GetCommandFromTask(). This includes handling Func<Task> for parameterless async commands and Func<T, Task> for async commands with parameters, utilizing CancellationToken for cancellation.

```csharp
public IDynamicCommand WaitASecond => this.GetCommandFromTask(async ct =>
{
  await Task.Delay(1000, ct);
});

public IDynamicCommand Wait => this.GetCommandFromTask<int>(async (ct, parameter) =>
{
  await Task.Delay(TimeSpan.FromSeconds(parameter), ct);
});
```

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

### Creating Dynamic Properties with Initial Values

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates various ways to create dynamic properties with specified initial values. This includes setting a default value, providing a literal value, and initializing from a Task or an Observable.

```csharp
public int MyProperty => this.Get<int>();

// This will create and attach a new IDynamicProperty named "MyPropertyWithInitialValue"
// to your IViewModel. It's initial value will be 10.
public int MyPropertyWithInitialValue => this.Get(10));

// This will create and attach a new IDynamicProperty named "MyPropertyFromTask"
// to your IViewModel. It's initial value will be 10 and will be updated to 20
// once MyTask completes.
public int MyPropertyFromTask => this.GetFromTask<int>(MyTask, initialValue: 10);
private Task<int> MyTask(CancellationToken ct) => Task.FromResult(20);

// This will create and attach a new IDynamicProperty named "MyPropertyFromObservable"
// to your IViewModel. It's initial value will be 10 and will be updated to 20
// once MyObservable pushes a new value.
public int MyPropertyFromObservable => this.GetFromObservable(MyObservable, initialValue: 10);
private IObservable<int> MyObservable => Observable.Return(20);
```

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

### Basic MainPage.xaml Binding

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Provides a simple XAML structure for `MainPage` that demonstrates data binding to the `MainPageViewModel`. It includes a `TextBox` for input, a `Button` to trigger a command, and a `TextBlock` to display results, all bound to ViewModel properties.

```xml
<Page x:Class="ChinookSample.MainPage"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <StackPanel>
     <TextBox Text="{Binding Content, Mode=TwoWay}" />

     <Button Content="Submit"
             Command="{Binding Submit}" />

     <TextBlock Text="{Binding Result}" />
  </StackPanel>
</Page>
```

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

### Incorrect Child ViewModel Declaration

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

This C# example highlights an incorrect way to declare a child ViewModel by directly instantiating it without using the provided `GetChild`, `AttachChild`, or `AttachOrReplaceChild` methods. This can lead to issues with `IDispatcher` not being set, potentially causing `PropertyChanged` events to be raised on the wrong thread.

```csharp
public SettingsViewModel Settings { get; } = new SettingsViewModel();
```

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

### Decorating Command with Logging Strategy

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Demonstrates how to decorate an ActionCommandStrategy with logging capabilities using the WithLogs extension method. This enhances the command by adding logging to its execution lifecycle.

```csharp
var myCommandStrategy = new ActionCommandStrategy(ExecuteCommand);

// This will decorate the command with logs
var myStrategyWithLogs = myCommandStrategy.WithLogs(logger);

var myCommand = new DynamicCommand("MyCommand", myStrategyWithLogs);
void ExecuteCommand() { }
```

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

### Attaching Dynamic Commands

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates how to create and attach a dynamic command to an IViewModel. This involves defining an execution method and using the GetCommand helper to link it to a property.

```csharp
public IDynamicCommand MyCommand => this.GetCommand(Execute);

private void Execute()
{
  // This method will be called when MyCommand is executed.
}
```

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

### Create DynamicCommand from Action

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Illustrates creating a DynamicCommand using an ActionCommandStrategy, which executes a specified action method when the command is invoked.

```csharp
var myCommandStrategy = new ActionCommandStrategy(ExecuteCommand);
var myCommand = new DynamicCommand("MyCommand", myCommandStrategy);
void ExecuteCommand() { }
```

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

### Create DynamicProperty with Initial Value (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Demonstrates creating a DynamicProperty with a specified name and an initial integer value. This is a fundamental way to instantiate a dynamic property.

```csharp
var myProperty = new DynamicProperty<int>("MyProperty", value: 10);
```

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

### Create DynamicCommand with Parameter

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Shows how to create an IDynamicCommand named 'MyCommandWithParameter' that accepts an integer parameter and executes a specified method with that parameter. The command is attached to the IViewModel.

```C#
public class MyViewModel : ViewModelBase
{
  // This will create and attach a new IDynamicCommand named "MyCommandWithParameter"
  // to your IViewModel. It will call the ExecuteWithParameter method with its
  // command parameter when executed.
  public IDynamicCommand MyCommandWithParameter => this.GetCommand<int>(ExecuteWithParameter);
  private void ExecuteWithParameter(int parameter) { }
}
```

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

### Override Default Command Configuration

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Explains how to override or clear default configurations applied by the IDynamicCommandBuilderFactory, demonstrating the removal of a strategy and the application of a new one.

```csharp
var myFactory = new DynamicCommandBuilderFactory(c => c
  .ExecuteOnBackgroundThread()
  .CatchErrors(HandleCommandError)
  .WithLogs()
));

var myBuilder = myFactory.CreateFromAction("MyCommand", ExecuteCommand)
  .WithoutStrategy<BackgroundCommandStrategy>();

var myCommand = myBuilder.Build();

var myBuilder2 = myFactory.CreateFromAction("MyCommand2", ExecuteCommand)
  .ClearStrategies()
  .DisableWhileExecuting();

var myCommand2 = myBuilder2.Build();

private void ExecuteCommand() { }
```

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

### Decorate DynamicCommand with Logs

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Shows how to decorate an existing IDynamicCommand with logging capabilities using the WithLogs() extension method. This allows for logging command executions.

```C#
public class MyViewModel : ViewModelBase
{
  // This will add logs to your command.
  public IDynamicCommand MyCommand => this.GetCommand(Execute, c => c.WithLogs());
  private void Execute() { }
}
```

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

### Observe DynamicProperty Value Changes (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Shows how to use the 'Observe' extension method to subscribe to value changes of a DynamicProperty. The provided lambda function is executed each time the value changes.

```csharp
myProperty.Observe().Subscribe(value =>
{
  // This will be called everytime the value of the property changes.
});
```

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

### Configure Factory-Level Command Behavior

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

This C# code snippet demonstrates how to configure default command behavior at the factory level using `IDynamicCommandBuilderFactory`. It adds logging and specifies execution on a background thread for all commands created by this factory.

```csharp
.AddSingleton<IDynamicCommandBuilderFactory>(s =>
    new DynamicCommandBuilderFactory(builder => builder
        .WithLogs(s.GetRequiredService<ILogger<IDynamicCommand>>())
        .OnBackgroundThread()
))
```

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

### Set Default ServiceProvider in Application Startup

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows the crucial step of setting the configured `IServiceProvider` into `ViewModelBase.DefaultServiceProvider`. This allows ViewModels to access the necessary factories for dynamic property and command management throughout the application's lifecycle.

```csharp
ViewModelBase.DefaultServiceProvider = serviceProvider;
```

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

### Integrate Dispatcher for UI Thread Updates (Uno/WinUI)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates how to integrate a dispatcher for handling UI thread updates when using `Chinook.DynamicMvvm` with WinUI or Uno.WinUI applications. It shows initializing `MainPageViewModel` with a `DispatcherQueueDispatcher` to ensure property change notifications occur on the main thread.

```csharp
public MainPage()
{
    this.InitializeComponent();
    DataContext = new MainPageViewModel()
    {
        Dispatcher = new DispatcherQueueDispatcher(this)
    };
}
```

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

### Create DynamicCommand from Action with Parameter

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Demonstrates creating a DynamicCommand that accepts an integer parameter. The command's execution strategy is an ActionCommandStrategy that takes an integer.

```csharp
var myCommandStrategy = new ActionCommandStrategy<int>(ExecuteCommand);
var myCommand = new DynamicCommand("MyCommandWithParameter", myCommandStrategy);
void ExecuteCommand(int parameter) { }
```

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

### Resolve Service from IViewModel

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Shows how to resolve registered services from the IViewModel's IServiceProvider. This allows access to dependencies like IMyService.

```C#
public class MyViewModel : ViewModelBase
{
  // This will return the registered service of type IMyService.
  private IMyService _myService => this.ServiceProvider.GetRequiredService<IMyService>();
}
```

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

### Initialize List with ItemViewModels in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows how to initialize a collection of ItemViewModels within a parent ViewModel. Each ItemViewModel is created and attached as a child, with its name set to its title for easy reference.

```csharp
public MainPageViewModel()
{
  IEnumerable<string> someSource = Enumerable
    .Range(0, 10)
    .Select(i => i.ToString());
  Items = someSource
    .Select(title => this.AttachChild(new ItemViewModel { Title = title }, name: title))
    .ToArray();
}

public ItemViewModel[] Items { get; }
```

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

### Regular vs. Dynamic Properties (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Illustrates the difference between regular C# properties and dynamic properties backed by IDynamicProperty. Regular properties do not automatically raise PropertyChanged events, while dynamic properties do. It's recommended to use regular properties for data that never changes to save memory.

```csharp
public string Title => "Hello"; // Regular property
public string Subtitle { get; } // Regular property

public long Counter => this.GetFromObservable(ObserveTimer()); // Dynamic Property
public bool IsFavorite // Dynamic property
{
  get => this.Get(initialValue: false);
  set => this.Set(value);
}
```

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

### Create DynamicCommand without Parameter

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates creating an IDynamicCommand named 'MyCommand' that executes a specified method when invoked. This command is attached to the IViewModel.

```C#
public class MyViewModel : ViewModelBase
{
  // This will create and attach a new IDynamicCommand named "MyCommand"
  // to your IViewModel. It will call the Execute method when executed.
  public IDynamicCommand MyCommand => this.GetCommand(Execute);
  private void Execute() { }
}
```

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

### Resolve Service from ViewModel in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Illustrates how to retrieve a service, such as an ILogger, from the ViewModel's service provider using the IViewModel.GetService method. The IServiceProvider is also directly accessible via IViewModel.ServiceProvider.

```csharp
var logger = this.GetService<ILogger<MainPageViewModel>>();
```

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

### Inject Service using InjectAttribute

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates using the [Inject] attribute to automatically resolve and inject services (e.g., IMyService) into a ViewModel. Requires the ViewModel class to be partial.

```C#
public partial class MyViewModel : ViewModelBase
{
  // This will return the registered service of type IMyService.
  [Inject] private IMyService _myService;
}
```

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

### Register DynamicCommandFactory

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates how to register a custom IDynamicCommandFactory with the IServiceCollection to alter the creation process of IDynamicCommands.

```C#
private void ConfigureCommands(IServiceCollection services)
{
  services.AddSingleton<IDynamicCommandFactory, DynamicCommandFactory>();
}
```

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

### Create DynamicCommand from Task with Parameter

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Demonstrates creating an IDynamicCommand named 'MyCommandFromTaskWithParameter' that executes an asynchronous task with an integer parameter. The CancellationToken will be cancelled upon IViewModel disposal.

```C#
public class MyViewModel : ViewModelBase
{
  // This will create and attach a new IDynamicCommand named "MyCommandFromTaskWithParameter"
  // to your IViewModel. It will call the ExecuteMyTaskWithParameter method with its
  // command parameter when executed. The CancellationToken will be cancelled if the IViewModel is disposed.
  public IDynamicCommand MyCommandFromTaskWithParameter => this.GetCommandFromTask<int>(ExecuteMyTaskWithParameter);
  private async Task ExecuteMyTaskWithParameter(CancellationToken ct, int parameter) => Task.CompletedTask;
}
```

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

### Create DynamicProperty from Observable (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Explains how to create a DynamicProperty initialized with an observable sequence. The property's value updates and notifies subscribers when the observable emits a new value.

```csharp
var myObservable = Observable.Return(20);
var myPropertyFromObservable = new DynamicPropertyFromObservable<int>("MyPropertyFromObservable", myObservable, initialValue: 10);
```

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

### Attaching Child ViewModels

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Explains how to compose ViewModels by attaching child ViewModels to a parent IViewModel. The child ViewModel's lifecycle is managed in conjunction with its parent, simplifying resource management.

```csharp
public IViewModel MyChild => this.GetChild(() => new MyChildViewModel());

public class MyChildViewModel : ViewModelBase
{
}
```

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

### Attaching Two-Way Dynamic Properties

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Illustrates the creation and attachment of two-way dynamic properties. These properties have both a getter and a setter, enabling data to flow both from the ViewModel to the View and from the View back to the ViewModel.

```csharp
public int MyTwoWayProperty
{
  get => this.Get<int>();
  set => this.Set(value);
}
```

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

### Create DynamicProperty from Task (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Demonstrates creating a DynamicProperty from an asynchronous task. When the task completes, the property's value is updated with the task's result, triggering notifications.

```csharp
Task<int> MyTask(CancellationToken ct) => Task.FromResult(20);
var myPropertyFromTask = new DynamicPropertyFromTask<int>("MyPropertyFromTask", MyTask, initialValue: 10);
```

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

### Resolving Services from IViewModel

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Shows how to access services registered in the application's dependency injection container directly from within an IViewModel. This is achieved through the ServiceProvider property.

```csharp
private IMyService _myService => this.ServiceProvider.GetRequiredService<IMyService>();
```

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

### Create Simple ViewModel Property (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates how to declare a simple ViewModel property using IViewModel.Get. This property automatically raises the INotifyPropertyChanged event when its value is set. It utilizes an IDynamicProperty internally for lazy initialization.

```csharp
public string Content
{
  get => this.Get(initialValue: string.Empty);
  set => this.Set(value);
}
```

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

### Create DynamicCommand from Task

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Shows how to create a DynamicCommand from a TaskCommandStrategy, allowing asynchronous command execution. The provided task can be cancelled if the command is disposed during execution.

```csharp
var myCommandStrategy = new TaskCommandStrategy(ExecuteCommand);
var myCommand = new DynamicCommand("MyCommandFromTask", myCommandStrategy);
Task ExecuteCommand(CancellationToken ct) => Task.CompletedTask;
```

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

### Access IDynamicProperty Instance

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates how to retrieve the underlying IDynamicProperty<T> instance for a ViewModel property using GetProperty(). This allows direct manipulation of the property's value and subscription to its changes.

```csharp
public MainPageViewModel()
{
  IDynamicProperty<string> contentProperty;
  contentProperty = this.GetProperty(vm => vm.Content);
  // or
  contentProperty = this.GetProperty<string>(nameof(Content));
}

public string Content
{
  get => this.Get(initialValue: string.Empty);
  set => this.Set(value);
}
```

```csharp
contentProperty.Value = "Hello";
// This sets the property value. It also raises the PropertyChanged event on the ViewModel.

contentProperty.ValueChanged += prop => Console.WriteLine($"Property {prop.Name} changed to {prop.Value}.");
// This allows you to easily observe changes to a property value. Note that prop.Value is strongly type as a string here.
```

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

### Command Strategy Replacement (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/BREAKING_CHANGES.md

In version 0.11.0, `DecoratorCommandStrategy` was removed and replaced by `DelegatingCommandStrategy`. This change simplifies command composition.

```C#
// Before version 0.11.0
// using DynamicMvvm.Decorators;
// var command = new DecoratorCommandStrategy(...);

// After version 0.11.0
using DynamicMvvm.Delegating;
var command = new DelegatingCommandStrategy(...);
```

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

### Create DynamicCommand from Task with Parameter

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Command/IDynamicCommand.md

Illustrates creating a DynamicCommand from a TaskCommandStrategy that accepts an integer parameter. The command's task execution can be cancelled if the command is disposed.

```csharp
var myCommandStrategy = new TaskCommandStrategy<int>(ExecuteCommand);
var myCommand = new DynamicCommand("MyCommandFromTaskWithParameter", myCommandStrategy);
Task ExecuteCommand(CancellationToken ct, int parameter) => Task.CompletedTask;
```

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

### Define Validator for ViewModel in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows how to define a validator for a ViewModel using FluentValidation by creating a class that inherits from AbstractValidator and defining rules for properties.

```csharp
public class MainPageValidator : AbstractValidator<MainPageViewModel>
{
  public MainPageValidator()
  {
    RuleFor(vm => vm.Content).NotEmpty();
  }
}
```

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

### Subscribe to DynamicProperty Value Changes (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/Property/IDynamicProperty.md

Illustrates how to subscribe to the 'ValueChanged' event of a DynamicProperty to receive notifications whenever its value is modified. The handler receives the property itself.

```csharp
void OnValueChanged(IDynamicProperty property)
{
  var newValue = property.Value;
  
  // ...
}

myProperty.ValueChanged += OnValueChanged;
```

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

### Create DynamicCommand from Task

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Illustrates creating an IDynamicCommand named 'MyCommandFromTask' that executes an asynchronous task. The CancellationToken associated with the task will be cancelled if the IViewModel is disposed.

```C#
public class MyViewModel : ViewModelBase
{
  // This will create and attach a new IDynamicCommand named "MyCommandFromTask"
  // to your IViewModel. It will call the ExecuteMyTask method when executed.
  // The CancellationToken will be cancelled if the IViewModel is disposed.
  public IDynamicCommand MyCommandFromTask => this.GetCommandFromTask(ExecuteMyTask);
  private async Task ExecuteMyTask(CancellationToken ct) => Task.CompletedTask;
}
```

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

### Attaching One-Way Dynamic Properties

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Shows how to create and attach a one-way dynamic property to an IViewModel. One-way properties only provide a getter and are suitable for data that flows from the ViewModel to the View.

```csharp
public int MyOneWayProperty => this.Get<int>();
```

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

### Create Property from Task<T> (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates creating a ViewModel property that updates itself based on the result of a Task<T>. The property's value changes asynchronously when the task completes. It utilizes the IViewModel.GetFromTask method.

```csharp
// This property is initialized with the value 10, but changes to 100 after 1 second.
public int Number => this.GetFromTask(async ct =>
{
  await Task.Delay(1000, ct);
  return 100;
}, initialValue: 10);
```

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

### ViewModel-View Abstraction Change (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/BREAKING_CHANGES.md

Version 0.10.0 replaced `IViewModelView` with `IDispatcher` and `IViewModel.View` with `IViewModel.Dispatcher`. This change aims to provide a more focused abstraction for UI dispatching.

```C#
// Before version 0.10.0
// public interface IViewModelView { /* ... */ }
// public interface IViewModel
// {
//     IViewModelView View { get; }
// }

// After version 0.10.0
public interface IDispatcher { /* ... */ }
public interface IViewModel
{
    IDispatcher Dispatcher { get; }
}
```

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

### Create Property from IObservable<T> (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows how to create a ViewModel property that automatically updates its value when an IObservable<T> pushes a new value. This is useful for reactive programming patterns. It uses the IViewModel.GetFromObservable method.

```csharp
using System.Reactive.Linq;
// (...)
public long Counter => this.GetFromObservable(Observable.Timer(
  dueTime: TimeSpan.Zero,
  period: TimeSpan.FromSeconds(1))
);
```

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

### Declare Child ViewModel

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

This C# code illustrates how to declare a child ViewModel using the `GetChild` method. This is a recommended approach for organizing ViewModels and ensuring proper linking of the `IDispatcher` between parent and child ViewModels, which is crucial for correct event handling.

```csharp
public SettingsViewModel Settings => this.GetChild<SettingsViewModel>();
```

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

### Define ItemViewModel in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Demonstrates how to create an ItemViewModel inheriting from ViewModelBase, with a mutable 'IsFavorite' property that can be bound to in XAML. This allows individual list items to be updated without affecting the entire list.

```csharp
public class ItemViewModel : ViewModelBase
{
  public string Title { get; init; }
	
  public bool IsFavorite
  {
    get => this.Get(initialValue: false);
    set => this.Set(value);
  }
}
```

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

### Managing Property Setters for Dynamic Properties (C#)

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Explains how to control the mutability of dynamic properties. Properties can be made read-only by omitting the setter, settable from anywhere by including a public setter, or settable only within the ViewModel by using a private setter.

```csharp
public long Counter1 => this.GetFromObservable(ObserveTimer());

public long Counter2
{
  get => this.GetFromObservable(ObserveTimer());
  set => this.Set(value);
}

public long Counter3
{
  get => this.GetFromObservable(ObserveTimer());
  private set => this.Set(value);
}

private IObservable<long> ObserveTimer() => Observable.Timer(
  dueTime: TimeSpan.Zero,
  period: TimeSpan.FromSeconds(1));

private void SomeMethod()
{
  Counter1 = 0; // Doesn't build
  Counter2 = 0; // Builds
  Counter3 = 0; // Builds
}
```

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

### Attach Child ViewModel

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/src/DynamicMvvm.Abstractions/ViewModel/IViewModel.md

Explains how to attach a child ViewModel to a parent IViewModel, ensuring the child shares the parent's lifecycle. This is useful for modularity and shared functionality.

```C#
public class MyViewModel : ViewModelBase
{
  // This will create and attach a new child IViewModel named "MyChild"
  // to your IViewModel. The child will share its lifecycle with its parent ViewModel.
  public IViewModel MyChild => this.GetChild(() => new MyChildViewModel());

  // This will do the same as above but is a shortcut if your
  // IViewModel doesn't require any parameter.
  public IViewModel MyChild2 => this.GetChild<MyChildViewModel>();
}

public class MyChildViewModel : ViewModelBase
{
}
```

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

### Set ViewModel DataContext in MainPage.xaml.cs

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Shows how to set the `MainPageViewModel` as the `DataContext` for the `MainPage` in its code-behind file (`MainPage.xaml.cs`). This is a standard step in WPF/UWP/WinUI applications to bind the UI to the ViewModel.

```csharp
public MainPage()
{
  this.InitializeComponent();
  DataContext = new MainPageViewModel();
}
```

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

### Manually Validate ViewModel in C#

Source: https://github.com/nventive/chinook.dynamicmvvm/blob/main/README.md

Illustrates how to manually trigger validation for a ViewModel using the Validate method. This is often done before submitting data or performing an action that requires valid input.

```csharp
public IDynamicCommand Submit => this.GetCommandFromTask(async ct =>
{
  var result = await this.Validate(ct);
  if (result.IsValid)
  {
    Result = Content;
  }
});
```