### UWP View Model Integration

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

Example of binding a ViewModel to a UWP MainPage.

```csharp
public sealed partial class MainPage : Page
{
    public ViewModel ViewModel { get; } = new ViewModel();
    public MainPage()
    {
        this.InitializeComponent();
    }
}
```

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

### AsyncMessageBroker PublishAsync Example

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

Illustrates asynchronous pub-sub messaging with AsyncMessageBroker. It shows how to subscribe to async messages and use PublishAsync to await subscriber completion.

```csharp
AsyncMessageBroker.Default.Subscribe<MyClass>(async x =>
{
    Console.WriteLine("A:" + x);
    await Task.Delay(TimeSpan.FromSeconds(1));
});

var d = AsyncMessageBroker.Default.Subscribe<MyClass>(async x =>
{
    Console.WriteLine("B:" + x);
    await Task.Delay(TimeSpan.FromSeconds(2));
});

// await all subscriber complete
await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 100 });
await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 200 });
await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 300 });

d.Dispose(); // unsubscribe
await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 400 });
```

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

### MessageBroker Pub-Sub Example

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

Demonstrates basic pub-sub messaging using MessageBroker. Includes subscribing to messages, converting to an observable, publishing messages, and unsubscribing.

```csharp
using Reactive.Bindings.Notifiers;
using System;
using System.Reactive.Linq;
using System.Threading.Tasks;

public class MyClass
{
    public int MyProperty { get; set; }

    public override string ToString()
    {
        return "MP:" + MyProperty;
    }
}
class Program
{
    static void RunMessageBroker()
    {
        // global scope pub-sub messaging
        MessageBroker.Default.Subscribe<MyClass>(x =>
        {
            Console.WriteLine("A:" + x);
        });

        var d = MessageBroker.Default.Subscribe<MyClass>(x =>
        {
            Console.WriteLine("B:" + x);
        });

        // support convert to IObservable<T>
        MessageBroker.Default.ToObservable<MyClass>().Subscribe(x =>
        {
            Console.WriteLine("C:" + x);
        });

        MessageBroker.Default.Publish(new MyClass { MyProperty = 100 });
        MessageBroker.Default.Publish(new MyClass { MyProperty = 200 });
        MessageBroker.Default.Publish(new MyClass { MyProperty = 300 });

        d.Dispose(); // unsubscribe
        MessageBroker.Default.Publish(new MyClass { MyProperty = 400 });
    }

    static async Task RunAsyncMessageBroker()
    {
        // asynchronous message pub-sub
        AsyncMessageBroker.Default.Subscribe<MyClass>(async x =>
        {
            Console.WriteLine("A:" + x);
            await Task.Delay(TimeSpan.FromSeconds(1));
        });

        var d = AsyncMessageBroker.Default.Subscribe<MyClass>(async x =>
        {
            Console.WriteLine("B:" + x);
            await Task.Delay(TimeSpan.FromSeconds(2));
        });

        // await all subscriber complete
        await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 100 });
        await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 200 });
        await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 300 });

        d.Dispose(); // unsubscribe
        await AsyncMessageBroker.Default.PublishAsync(new MyClass { MyProperty = 400 });
    }

    static void Main(string[] args)
    {
        Console.WriteLine("MessageBroker");
        RunMessageBroker();

        Console.WriteLine("AsyncMessageBroker");
        RunAsyncMessageBroker().Wait();
    }
}
```

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

### UWP Page Setup for Validation Errors

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

This C# code sets up a UWP page with a ViewModel that handles validation errors. It initializes the ViewModel and the page components.

```csharp
public sealed partial class MainPage : Page
{
    private ViewModel ViewModel { get; } = new ViewModel();
    public MainPage()
    {
        this.InitializeComponent();
    }
}
```

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

### Bind AsyncReactiveCommand in XAML

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

Example of binding the AsyncReactiveCommand and a ReactiveProperty to UI elements in a XAML page.

```xml
<Page x:Class="App1.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:local="using:App1"
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      mc:Ignorable="d">
    <StackPanel Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Button Content="Heavy command"
                Command="{x:Bind ViewModel.HeavyCommand}"
                Margin="5" />
        <TextBlock Text="{x:Bind ViewModel.Message.Value, Mode=OneWay}"
                   Margin="5" />
    </StackPanel>
</Page>
```

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

### Partial MainPage definition

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Event-transfer-to-ViewModel-from-View.md

A partial code block showing the start of the MainPage class definition.

```csharp
using Reactive.Bindings;
using Windows.UI.Xaml.Controls;

namespace App1
{
    public sealed partial class MainPage : Page
    {
```

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

### Basic ReactiveProperty Usage

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Demonstrates creating a ReactiveProperty, setting up event handlers for PropertyChanged and Subscribe callbacks, and updating the value.

```csharp
using Reactive.Bindings;
using System;

namespace ReactivePropertyEduApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // create from defualt constructor(default value is null)
            var name = new ReactiveProperty<string>();
            // setup the event handler and the onNext callback.
            name.PropertyChanged += (_, e) => Console.WriteLine($"PropertyChanged: {e.PropertyName}");
            name.Subscribe(x => Console.WriteLine($"OnNext: {x}"));

            // update the value property.
            name.Value = "neuecc";
            name.Value = "xin9le";
            name.Value = "okazuki";
        }
    }
}
```

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

### Initialize and Use ReactiveProperty

Source: https://context7.com/runceel/reactiveproperty/llms.txt

Demonstrates creating, subscribing to, and updating ReactiveProperty instances, including conversion from IObservable and LINQ chaining.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;

// Create ReactiveProperty with default value
var name = new ReactiveProperty<string>();

// Create with initial value
var nameWithDefault = new ReactiveProperty<string>("initial value");

// Subscribe to value changes
name.Subscribe(x => Console.WriteLine($"OnNext: {x}"));
name.PropertyChanged += (_, e) => Console.WriteLine($"PropertyChanged: {e.PropertyName}");

// Update value - triggers both OnNext and PropertyChanged
name.Value = "neuecc";
name.Value = "xin9le";

// Create from IObservable<T>
ReactiveProperty<long> counter = Observable.Interval(TimeSpan.FromSeconds(1))
    .ToReactiveProperty();

// Chain ReactiveProperties with LINQ
var input = new ReactiveProperty<string>("");
var output = input
    .Where(x => !string.IsNullOrEmpty(x))
    .Select(x => x.ToUpper())
    .Delay(TimeSpan.FromSeconds(1))
    .ToReactiveProperty();

// Output: OnNext: (empty), OnNext: neuecc, PropertyChanged: Value, OnNext: xin9le, PropertyChanged: Value
```

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

### WPF ViewModel with Reactive Properties and Commands

Source: https://context7.com/runceel/reactiveproperty/llms.txt

Demonstrates setting up ReactiveProperty for input/output, a ReactiveCommand for handling drop events, and a ReactiveProperty for mouse position in a WPF ViewModel.

```csharp
using Reactive.Bindings;
using Reactive.Bindings.Interactivity;
using System;
using System.Reactive.Linq;
using System.Windows;

public class WpfViewModel
{
    public ReactiveProperty<string> Input { get; }
    public ReadOnlyReactiveProperty<string> Output { get; }
    public ReactiveCommand<DragEventArgs> DropCommand { get; }
    public ReactiveProperty<Point> MousePosition { get; }

    public WpfViewModel()
    {
        Input = new ReactiveProperty<string>("");
        Output = Input
            .Delay(TimeSpan.FromSeconds(1))
            .Select(x => x.ToUpper())
            .ToReadOnlyReactiveProperty();

        // Command for handling drop events
        DropCommand = new ReactiveCommand<DragEventArgs>()
            .WithSubscribe(e =>
            {
                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    var files = (string[])e.Data.GetData(DataFormats.FileDrop);
                    Console.WriteLine($
```

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

### BusyNotifier

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

BusyNotifier implements IObservable<bool> to indicate when a process is running. It raises true when a process starts and false when all processes have ended.

```APIDOC
## BusyNotifier

### Description
Implements `IObservable<bool>` to signal when a process is active. It emits `true` when any process starts and `false` when all registered processes have completed.

### Methods
- **ProcessStart()**: Returns an `IDisposable` that marks the start of a process. Disposing this object signals the end of the process.

### Usage Example
```csharp
using Reactive.Bindings.Notifiers;
using System;
using System.Threading.Tasks;

// Assume this is within a class with Main method
var b = new BusyNotifier();
b.Subscribe(x => Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: OnNext: {x}"));

await Task.WhenAll(
    Task.Run(async () =>
    {
        using (b.ProcessStart())
        {
            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process1 started.");
            await Task.Delay(TimeSpan.FromSeconds(1));
            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process1 finished.");
        }
    }),
    Task.Run(async () =>
    {
        using (b.ProcessStart())
        {
            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process2 started.");
            await Task.Delay(TimeSpan.FromSeconds(2));
            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process2 finished.");
        }
    })
);
```

### Expected Output Example
```
15:07:45: OnNext: False
15:07:45: OnNext: True
15:07:45: Process1 started.
15:07:45: Process2 started.
15:07:46: Process1 finished.
15:07:47: Process2 finished.
15:07:47: OnNext: False
```
```

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

### Create and subscribe to ReactiveCommand

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

Demonstrates using the WithSubscribe extension method to create and subscribe to a command in a single statement.

```csharp
public class ViewModel
{
    public ReactiveCommand UpdateTimeCommand { get; }

    public ReactiveProperty<string> Time { get; }

    public ViewModel()
    {
        Time = new ReactiveProperty<string>();

        var updateTimeTrigger = new Subject<Unit>();
        UpdateTimeCommand = Observable.Merge(
            updateTimeTrigger.Select(_ => false),
            updateTimeTrigger.Delay(TimeSpan.FromSeconds(5)).Select(_ => true))
            .ToReactiveCommand()
            .WithSubscribe(() => Time.Value = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")); // here
    }
}
```

```csharp
// No use the WithSubscribe
var command = new ReactiveCommand();
command.Subscribe(_ => { ... some actions ... });

// Use the WithSubscribe
var command = new ReactiveCommand()
    .WithSubscribe(() => { ... some actions ... });
```

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

### Code behind for MainPage

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

Initialize the ViewModel in the page code-behind.

```csharp
// code behind
using Windows.UI.Xaml.Controls;

namespace RPSample
{
    public sealed partial class MainPage : Page
    {
        private MainPageViewModel ViewModel { get; } = new MainPageViewModel();
        public MainPage()
        {
            InitializeComponent();
        }
    }
}
```

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

### BusyNotifier with Multiple Tasks

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

Illustrates the use of BusyNotifier to track the start and end of multiple asynchronous processes. It raises true when any process is active and false when all have completed.

```csharp
using Reactive.Bindings.Notifiers;
using System;
using System.Threading.Tasks;

namespace ReactivePropertyEduApp
{
    class Program
    {
        static void Main(string[] args)
        {
            MainAsync(args).Wait();
        }

        static async Task MainAsync(string[] args)
        {
            var b = new BusyNotifier();
            b.Subscribe(x => Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: OnNext: {x}"));

            await Task.WhenAll(
                Task.Run(async () =>
                {
                    using (b.ProcessStart())
                    {
                        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process1 started.");
                        await Task.Delay(TimeSpan.FromSeconds(1));
                        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process1 finished.");
                    }
                }),
                Task.Run(async () =>
                {
                    using (b.ProcessStart())
                    {
                        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process2 started.");
                        await Task.Delay(TimeSpan.FromSeconds(2));
                        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: Process2 finished.");
                    }
                }));
        }
    }
}
```

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

### Initialize Prism Module

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/advanced/work-with-other-mvvm-framwork.md

Implement the IModule interface to register views for navigation and request navigation upon initialization.

```csharp
using PrismSampleModule.Views;
using Prism.Ioc;
using Prism.Modularity;
using Prism.Regions;

namespace PrismSampleModule
{
    public class PrismSampleModuleModule : IModule
    {
        private readonly IRegionManager _regionManager;

        public PrismSampleModuleModule(IRegionManager regionManager)
        {
            _regionManager = regionManager;
        }

        public void OnInitialized(IContainerProvider containerProvider)
        {
            _regionManager.RequestNavigate("ContentRegion", "ViewA");
        }

        public void RegisterTypes(IContainerRegistry containerRegistry)
        {
            containerRegistry.RegisterForNavigation<ViewA>();
        }
    }
}
```

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

### XAML for ReadOnlyReactiveCollection Example

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

This XAML defines a page with a button to trigger a reset command and a ListView to display messages from a ViewModel. The ListView's ItemsSource is bound to the ViewModel's Messages collection.

```xml
<Page x:Class="App1.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:local="using:App1"
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      mc:Ignorable="d">
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <Button Content="Reset"
                Command="{x:Bind ViewModel.ResetCommand}"
                Margin="5" />
        <ListView ItemsSource="{x:Bind ViewModel.Messages}"
                  Grid.Row="1" />
    </Grid>
</Page>
```

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

### Initialize ViewModel in MainPage

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/uno-platform.md

Instantiates the ViewModel within the code-behind of the main page.

```csharp
using Windows.UI.Xaml.Controls;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace GettingStartedUno
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private MainPageViewModel ViewModel { get; } = new MainPageViewModel();
        public MainPage()
        {
            this.InitializeComponent();
        }
    }
}
```

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

### Create and Use ReactivePropertySlim

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactivePropertySlim.md

Instantiate ReactivePropertySlim with an initial value, subscribe to its changes with a transformation, and update its value.

```csharp
var rp = new ReactivePropertySlim<string>("neuecc");
rp.Select(x => $"{x}-san").Subscribe(x => Console.WriteLine(x));
rp.Value = "xin9le";
rp.Value = "okazuki";
```

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

### Create ReadOnlyReactiveCollection from IObservable

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

ReadOnlyReactiveCollection can be created from an IObservable. The `onReset` argument, an IObservable<Unit>, can be used to clear the collection when it raises a value. This example demonstrates creating a collection of timestamp strings that resets when a command is executed.

```csharp
public class ViewModel
{
    public ReadOnlyReactiveCollection<string> Messages { get; }

    public ReactiveCommand ResetCommand { get; }

    public ViewModel()
    {
        ResetCommand = new ReactiveCommand();
        Messages = Observable.Interval(TimeSpan.FromSeconds(1))
            .Select(_ => DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"))
            .ToReadOnlyReactiveCollection(ResetCommand.ToUnit());
    }
}
```

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

### Create ReactiveCollection from IObservable

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

Demonstrates initializing a ReactiveCollection within a ViewModel using an IObservable source.

```csharp
public class ViewModel
{
    public ReactiveCollection<DateTime> Records { get; }

    public ReactiveCommand StartRecordCommand { get; }

    public ViewModel()
    {
        StartRecordCommand = new ReactiveCommand();
        // Create a ReactiveCollection instance from IObservable
        Records = StartRecordCommand
            .ToUnit()
            .Take(1)
            .Concat(Observable.Defer(() => Observable.Interval(TimeSpan.FromSeconds(1)).ToUnit()))
            .Select(_ => DateTime.Now)
            .ToReactiveCollection();
    }
}
```

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

### Implement a Reactive ViewModel

Source: https://github.com/runceel/reactiveproperty/blob/main/README.md

Demonstrates using ReactivePropertySlim and ReadOnlyReactivePropertySlim to create a reactive data flow in a ViewModel.

```csharp
public class MainPageViewModel
{
    public ReactivePropertySlim<string> Input { get; }
    public ReadOnlyReactivePropertySlim<string> Output { get; }
    public MainPageViewModel()
    {
        Input = new ReactivePropertySlim<string>("");
        Output = Input
            .Delay(TimeSpan.FromSeconds(1))
            .Select(x => x.ToUpper())
            .ObserveOnDispatcher()
            .ToReadOnlyReactivePropertySlim();
    }
}
```

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

### MainPage Code-Behind C#

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/uwp.md

Initializes the MainPage with an instance of MainPageViewModel. This file sets up the page's code-behind logic.

```csharp
using Windows.UI.Xaml.Controls;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace GettingStartedUWP
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private MainPageViewModel ViewModel { get; } = new MainPageViewModel();
        public MainPage()
        {
            this.InitializeComponent();
        }
    }
}
```

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

### Configure Program.cs for Wasm

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/uno-platform.md

Enables Reactive Extensions support in the WebAssembly project entry point.

```csharp
using System;
using Windows.UI.Xaml;
using System.Reactive.PlatformServices; // add

namespace GettingStartedUno.Wasm
{
    public class Program
    {
        private static App _app;

        static int Main(string[] args)
        {
#pragma warning disable CS0618 // Type or member is obsolete
            PlatformEnlightenmentProvider.Current.EnableWasm(); // add
#pragma warning restore CS0618 // Type or member is obsolete
            Windows.UI.Xaml.Application.Start(_ => _app = new App());

            return 0;
        }
    }
}
```

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

### Initialize ReactiveProperty with default behavior

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Demonstrates the default behavior where subscribing triggers an immediate callback with the current value.

```csharp
var x = new ReactiveProperty<string>("initial value");
x.Subscribe(x => Console.WriteLine(x)); // -> initial value
```

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

### Initialize ReactiveProperty Scheduler for WPF

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/wpf.md

Set up the default scheduler for ReactiveProperty in the application's startup event handler. This is crucial for ensuring proper execution of reactive operations on the UI thread.

```csharp
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using Reactive.Bindings;
using Reactive.Bindings.Schedulers;

namespace WpfApp1
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            ReactivePropertyScheduler.SetDefault(new ReactivePropertyWpfScheduler(Dispatcher));
        }
    }
}
```

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

### Create ReactiveProperty with Initial Value

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Demonstrates creating a ReactiveProperty instance with an explicit initial value provided to the constructor.

```csharp
// create with the initial value.
var name = new ReactiveProperty<string>("okazuki");
Console.WriteLine(name.Value); // -> okazuki
```

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

### Create ReactiveProperty with Default Value

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Shows how to create a ReactiveProperty instance using the default constructor, which initializes the value to its default (e.g., null for string).

```csharp
// create with the default value.
var name = new ReactiveProperty<string>();
Console.WriteLine(name.Value); // -> empty output
```

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

### Implement a Standard ViewModel with INotifyPropertyChanged

Source: https://github.com/runceel/reactiveproperty/blob/main/README.md

Standard implementation of a ViewModel requiring manual property change notification and command status updates.

```csharp
public class AViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));

            // Update a command status
            DoSomethingCommand.RaiseCanExecuteChanged();
        }
    }

    private string _memo;
    public string Memo
    {
        get => _memo;
        set
        {
            _memo = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Memo)));

            // Update a command status
            DoSomethingCommand.RaiseCanExecuteChanged();
        }
    }

    // DelegateCommand is plane ICommand implementation.
    public DelegateCommand DoSomethingCommand { get; }

    public AViewModel()
    {
        DoSomethingCommand = new DelegateCommand(
            () => { ... },
            () => !string.IsNullOrEmpty(Name) && !string.IsNullOrEmpty(Memo)
        );
    }
}
```

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

### Define MainPageViewModel with ReactiveProperty

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/xf.md

Implements a ViewModel using ReactiveProperty for input and ReadOnlyReactiveProperty for processed output.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;

namespace GettingStartedXF
{
    public class MainPageViewModel
    {
        public ReactiveProperty<string> Input { get; }
        public ReadOnlyReactiveProperty<string> Output { get; }

        public MainPageViewModel()
        {
            Input = new ReactiveProperty<string>("");
            Output = Input
                .Delay(TimeSpan.FromSeconds(1))
                .Select(x => x.ToUpper())
                .ToReadOnlyReactiveProperty();
        }
    }
}
```

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

### Define ViewModel for EventToReactiveCommand

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Event-transfer-to-ViewModel-from-View.md

Set up the ViewModel with ReactiveCommand and ReadOnlyReactiveProperty to handle the incoming event data.

```csharp
using Reactive.Bindings;
using Windows.UI.Xaml.Controls;

namespace App1
{
    public sealed partial class MainPage : Page
    {
        public MainPageViewModel ViewModel { get; } = new MainPageViewModel();

        public MainPage()
        {
            this.InitializeComponent();
        }
    }

    public class MainPageViewModel
    {
        public ReactiveCommand<string> SelectFileCommand { get; }
        public ReadOnlyReactiveProperty<string> FileName { get; }

        public MainPageViewModel()
        {
            this.SelectFileCommand = new ReactiveCommand<string>();
            this.FileName = this.SelectFileCommand.ToReadOnlyReactiveProperty();
        }
    }

}
```

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

### Awaitable ReactiveCommand and ReactiveProperty usage

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/advanced/awaitable.md

Demonstrates handling ReactiveCommand events using async/await within a ViewModel and managing the lifecycle with a CancellationToken in the View.

```csharp
// View with CancellationTokenSource
public partial class SampleWindow : Window
{
    CancellationTokenSource cts;
    SampleViewModel viewModel;

    public SampleWindow()
    {
        InitializeComponent();
        cts = new CancellationTokenSource();
        viewModel = new SampleViewModel(cts.Token);
    }

    protected override void OnClosed(EventArgs e)
    {
        // on finish, cancel all await.
        cts.Cancel();
        cts.Dispose();

        base.OnClosed(e);
    }
}

// ViewModel with CancellationToken
public class SampleViewModel
{
    public ReactiveCommand MyCommand { get; private set; }
    public ReactiveProperty<int> ClickCount { get; private set; }

    public SampleViewModel(CancellationToken closeToken)
    {
        MyCommand = new ReactiveCommand();
        ClickCount = new ReactiveProperty<int>();

        // handling event by async/await.
        SubscribeAsync(closeToken);
    }

    async void SubscribeAsync(CancellationToken closeToken)
    {
        using (var handler = MyCommand.GetAsyncHandler(closeToken))
        {
            while (true)
            {
                await handler; // await when clicked.
                ClickCount.Value += 1;
            }
        }
    }
}
```

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

### Implement ReactiveCommand

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/README.md

Create a ReactiveCommand from an IObservable<bool> to control execution state based on property values.

```csharp
class ViewModel
{
    public ReactiveProperty<string> Input { get; }
    public ReactiveProperty<string> Output { get; }

    public ReactiveCommand ResetCommand { get; }

    public ViewModel()
    {
        Input = new ReactiveProperty("");
        // Same as above sample
        Output = Input
            .Delay(TimeSpan.FromSecond(1)) // Using a Rx method.
            .Select(x => x.ToUpper()) // Using a LINQ method.
            .ToReactiveProperty(); // Convert to ReactiveProperty
        
        ResetCommand = Input.Select(x => !string.IsNullOrWhitespace(x)) // Convert ReactiveProperty<string> to IObservable<bool>
            .ToReactiveCommand() // You can create ReactiveCommand from IObservable<bool> (When true value was published, then the command would be able to execute.)
            .WithSubscribe(() => Input.Value = ""); // This is a shortcut of ResetCommand.Subscribe(() => ...)
    }
}
```

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

### UWP XAML for Command and Property Binding

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

XAML structure for a UWP page, demonstrating how to bind a Button's Command property to a ViewModel's ReactiveCommand and a TextBlock's Text property to a ViewModel's ReactiveProperty using x:Bind.

```xml
<Page x:Class="App1.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:local="using:App1"
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      mc:Ignorable="d">
    <StackPanel Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Button Content="Update the time"
                Command="{x:Bind ViewModel.UpdateTimeCommand}"
                Margin="5" />
        <TextBlock Text="{x:Bind ViewModel.Time.Value, Mode=OneWay}"
                   Style="{ThemeResource BodyTextBlockStyle}"
                   Margin="5" />
    </StackPanel>
</Page>
```

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

### Define a ViewModel with ReactiveProperty

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/avalonia.md

Create a MainWindowViewModel that uses ReactiveProperty for input and a ReadOnlyReactiveProperty for processed output.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;

namespace AvaloniaApp
{
    public class MainWindowViewModel
    {
        public ReactiveProperty<string> Input { get; }
        public ReadOnlyReactiveProperty<string> Output { get; }
        public MainWindowViewModel()
        {
            Input = new ReactiveProperty<string>("");
            Output = Input
                .Delay(TimeSpan.FromSeconds(1))
                .Select(x => x.ToUpper())
                .ToReadOnlyReactiveProperty();
        }
    }
}
```

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

### Implement MainPageViewModel

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/uno-platform.md

Defines a ViewModel using ReactiveProperty and ReadOnlyReactiveProperty to transform input data.

```csharp
using Reactive.Bindings;
using System;
using System.Linq;
using System.Reactive.Linq;

namespace GettingStartedUno
{
    public class MainPageViewModel
    {
        public ReactiveProperty<string> Input { get; }
        public ReadOnlyReactiveProperty<string> Output { get; }

        public MainPageViewModel()
        {
            Input = new ReactiveProperty<string>("");
            Output = Input
                .Delay(TimeSpan.FromSeconds(1))
                .Select(x => x.ToUpper())
                .ToReadOnlyReactiveProperty();
        }
    }
}
```

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

### ReactiveProperty Modes

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Demonstrates how to configure the behavior of ReactiveProperty upon subscription using ReactivePropertyMode.

```APIDOC
## ReactiveProperty Modes

`ReactiveProperty` class calls the `OnNext` callback when `Subscribe` method called.

```csharp
var x = new ReactiveProperty<string>("initial value");
x.Subscribe(x => Console.WriteLine(x)); // -> initial value
```

You can change this behavior when a `ReactiveProperty` instance is created.
the constructor and `ToReactiveProperty` methods have `ReactivePropertyMode` arguments.
They can be set to the following values.

- `ReactivePropertyMode.None`
    - ReactiveProperty doesn't call the `OnNext` callback when `Subscribe` method is call. And calls the `OnNext` callback if the same value is set.
- `ReactivePropertyMode.DistinctUntilChanged`
    - This doesn't call `OnNext` callback if same value set.
- `ReactivePropertyMode.RaiseLatestValueOnSubscribe`
    - This calls `OnNext` callback when `Subscribe` method call.
- `ReactivePropertyMode.Default`
    - It is default value. It is same as `ReactivePropertyMode.DistinctUntilChanged | ReactivePropertyMode.RaiseLatestValueOnSubscribe`.
- `ReactivePropertyMode.IgnoreInitialValidationError`
    - Ignore initial validation error.

If you don't need this behavior, then you can set `ReactivePropertyMode.None` value.

```csharp
var rp = new ReactiveProperty<string>("initial value", mode: ReactivePropertyMode.None);
rp.Subscribe(x => Console.WriteLine(x)); // -> don't output value
rp.Value = "initial value"; // -> initial value
```
```

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

### Implement a ViewModel with ReactiveProperty

Source: https://github.com/runceel/reactiveproperty/blob/main/README.md

Simplified ViewModel implementation using ValidatableReactiveProperty and ReactiveCommandSlim to handle validation and command execution.

```csharp
public class AViewModel
{
    public ValidatableReactiveProperty<string> Name { get; }
    public ValidatableReactiveProperty<string> Memo { get; }
    public ReactiveCommandSlim DoSomethingCommand { get; }

    public AViewModel()
    {
        Name = new ValidatableReactiveProperty<string>("", 
            x => string.IsNullOrEmpty(x) ? "Invalid value" : null);
        Memo = new ValidatableReactiveProperty<string>("",
            x => string.IsNullOrEmpty(x) ? "Invalid value" : null);
        DoSomethingCommand = new[]
            {
                Name.ObserveHasErrors,
                Memo.ObserveHasErrors,
            }
            .CombineLatestValuesAreAllFalse()
            .ToReactiveCommand()
            .WithSubscribe(() => { ... });
    }
}
```

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

### Implement ReactivePropertySlim for Performance

Source: https://context7.com/runceel/reactiveproperty/llms.txt

Shows usage of the high-performance ReactivePropertySlim variant, which lacks automatic UI thread dispatching.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;

// Create ReactivePropertySlim (high performance)
var rp = new ReactivePropertySlim<string>("neuecc");

// Use like ReactiveProperty
rp.Select(x => $"{x}-san").Subscribe(x => Console.WriteLine(x));
rp.Value = "xin9le";
rp.Value = "okazuki";
// Output: neuecc-san, xin9le-san, okazuki-san

// Create ReadOnlyReactivePropertySlim from IObservable
var readOnlyRp = Observable.Interval(TimeSpan.FromSeconds(1))
    .Select(x => $"Count: {x}")
    .ToReadOnlyReactivePropertySlim();

// For UI thread dispatch, use ObserveOnUIDispatcher explicitly
var uiSafeRp = Observable.Interval(TimeSpan.FromSeconds(1))
    .ObserveOnUIDispatcher()
    .ToReadOnlyReactivePropertySlim();
```

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

### BooleanNotifier with ReactiveCommand

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

Shows how to use BooleanNotifier as a source for ReactiveCommand, either by explicitly setting the initial value or by using StartWith and Select.

```csharp
var n = new BooleanNotifier(); // the default value is false.

// CanExecute method of ReactiveCommand returns true as default. So, you set initialValue explicitly to `n.Value`.
var command = n.ToReactiveCommand(initialValue: n.Value);

// Or if you would like to convert to something using Select and others before calling ToReactiveCommand, you can use StartWith.
var command2 = n.StartWith(n.Value).Select(x => Something(x)).ToReactiveCommand();
```

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

### Configure Prism Module Catalog

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/advanced/work-with-other-mvvm-framwork.md

Register the module in the App.xaml.cs file to ensure it is loaded by the Prism shell.

```csharp
public partial class App
{
    protected override Window CreateShell()
    {
        return Container.Resolve<MainWindow>();
    }

    protected override void RegisterTypes(IContainerRegistry containerRegistry)
    {

    }

    protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
    {
        moduleCatalog.AddModule<PrismSampleModuleModule>();
    }
}
```

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

### BooleanNotifier Usage

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Notifiers.md

Demonstrates basic operations of BooleanNotifier including turning on/off, setting value, and subscribing to changes. Initial state defaults to false.

```csharp
var n = new BooleanNotifier();
n.Subscribe(x => Debug.WriteLine(x));

n.TurnOn(); // true
n.TurnOff(); // false
n.Value = true; // true
n.Value = false; // false
```

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

### Create AsyncReactiveCommand from IObservable

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

Demonstrates creating an AsyncReactiveCommand from an IObservable<bool> stream to control command availability.

```csharp
public class ViewModel
{
    public AsyncReactiveCommand HeavyCommand { get; }

    public ReactiveProperty<string> Message { get; } = new ReactiveProperty<string>();

    public ViewModel()
    {
        HeavyCommand = Observable.Interval(TimeSpan.FromSeconds(1))
            .Select(x => x % 2 == 0)
            .ToAsyncReactiveCommand()
            .WithSubscribe(async ()
            {
                Message.Value = "Heavy command started.";
                await Task.Delay(TimeSpan.FromSeconds(5));
                Message.Value = "Heavy command finished.";
            });
    }
}
```

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

### Implement ReactiveCommandSlim for High Performance

Source: https://context7.com/runceel/reactiveproperty/llms.txt

ReactiveCommandSlim offers better performance than ReactiveCommand, especially by not automatically dispatching CanExecuteChanged to the UI thread. Suitable for performance-critical scenarios.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;

public class ViewModel
{
    public ReactivePropertySlim<string> Input { get; }
    public ReactiveCommandSlim SaveCommand { get; }
    public ReactiveCommandSlim<int> IncrementCommand { get; }

    public ViewModel()
    {
        Input = new ReactivePropertySlim<string>("");

        // Create from validation state
        SaveCommand = Input
            .Select(x => !string.IsNullOrEmpty(x))
            .ToReactiveCommandSlim()
            .WithSubscribe(() => Console.WriteLine($"Saving: {Input.Value}"));

        // With command parameter
        IncrementCommand = new ReactiveCommandSlim<int>()
            .WithSubscribe(amount => Console.WriteLine($"Incrementing by {amount}"));
    }
}

// Benchmark comparison:
// CreateReactiveCommand:     291.931 ns
// CreateReactiveCommandSlim:   4.313 ns (67x faster)
// BasicUsecaseReactiveCommand:     1,187.294 ns
// BasicUsecaseReactiveCommandSlim:    91.861 ns (13x faster)

```

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

### ViewModel Without ReactiveProperty

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Illustrates a standard ViewModel implementation using the INotifyPropertyChanged interface for property updates, which requires manual event invocation.

```csharp
public class MainPageViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));
        }
    }

    // Other properties are defined similar codes.
}
```

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

### Set Global Scheduler Factory

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/advanced/thread.md

Configure a factory method to dynamically create scheduler instances, useful for multi-UI thread applications.

```csharp
using System.Reactive.Concurrency;
using System.Windows;
using System.Windows.Threading;
using Reactive.Bindings;

namespace MultiUIThreadApp
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Set to create a DispatcherScheduler instance when every instance is created 
            // for ReactiveProperty, ReadOnlyReactiveProperty, ReactiveCollection, and ReadOnlyReactiveProperty.
            ReactivePropertyScheduler.SetDefaultSchedulerFactory(() =>
                new DispatcherScheduler(Dispatcher.CurrentDispatcher));
        }
    }
}
```

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

### Manage IDisposable with AddTo

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Extension-methods.md

Compares manual CompositeDisposable management with the AddTo extension method for cleaner chaining.

```csharp
// init
var d = new CompositeDisposable();

Name = model.ObserveProperty(x => x.Name)
    .ToReadOnlyReactiveProperty();
d.Add(Name);

Age = model.ObserveProperty(x => x.Age)
    .ToReadOnlyReactiveProperty();
d.Add(Age);

// dispose all
d.Dispose();
```

```csharp
// init
var d = new CompositeDisposable();

Name = model.ObserveProperty(x => x.Name)
    .ToReadOnlyReactiveProperty()
    .AddTo(d);

Age = model.ObserveProperty(x => x.Age)
    .ToReadOnlyReactiveProperty()
    .AddTo(d);

// dispose all
d.Dispose();
```

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

### Create ReactiveProperty from IObservable

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/README.md

Transform observable sequences into ReactiveProperty instances using the ToReactiveProperty extension method.

```csharp
class ViewModel
{
    public ReactiveProperty<string> Input { get; }
    public ReactiveProperty<string> Output { get; }

    public ViewModel()
    {
        Input = new ReactiveProperty("");
        Output = Input
            .Delay(TimeSpan.FromSecond(1)) // Using a Rx method.
            .Select(x => x.ToUpper()) // Using a LINQ method.
            .ToReactiveProperty(); // Convert to ReactiveProperty
    }
}
```

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

### WPF ViewModel with Reactive Properties

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/wpf.md

Create a ViewModel that exposes ReactiveProperty for input and a ReadOnlyReactiveProperty for output. The output property transforms the input with a delay and converts it to uppercase.

```csharp
using Reactive.Bindings;
using System;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;

namespace WpfApp1
{
    class MainWindowViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        public ReactiveProperty<string> Input { get; }
        public ReadOnlyReactiveProperty<string> Output { get; }

        public MainWindowViewModel()
        {
            Input = new ReactiveProperty<string>("");
            Output = Input
                .Delay(TimeSpan.FromSeconds(1))
                .Select(x => x.ToUpper())
                .ToReadOnlyReactiveProperty();
        }
    }
}
```

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

### Bind Commands to View Events

Source: https://github.com/runceel/reactiveproperty/blob/main/README-Android.md

Uses SetCommand to link an IObservable event to a command.

```cs
this.FindViewById<Button>(Resource.Id.Button)
  .ClickAsObservable()
  .SetCommand(vm.AlertCommand);
```

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

### MainPageViewModel C# Implementation

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/uwp.md

Defines a ViewModel with a ReactiveProperty for input and a ReadOnlyReactiveProperty for transformed output. The output is delayed and converted to uppercase.

```csharp
using Reactive.Bindings;
using System;
using System.Linq;
using System.Reactive.Linq;

namespace GettingStartedUWP
{
    public class MainPageViewModel
    {
        public ReactiveProperty<string> Input { get; }
        public ReadOnlyReactiveProperty<string> Output { get; }

        public MainPageViewModel()
        {
            Input = new ReactiveProperty<string>("");
            Output = Input
                .Delay(TimeSpan.FromSeconds(1))
                .Select(x => x.ToUpper())
                .ToReadOnlyReactiveProperty();
        }
    }
}
```

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

### Implement ReactiveCommand with Observable CanExecute

Source: https://context7.com/runceel/reactiveproperty/llms.txt

ReactiveCommand implements ICommand and IObservable<T> for reactive command execution. CanExecute is managed automatically based on observable boolean sources. Supports commands with and without parameters.

```csharp
using Reactive.Bindings;
using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;

public class ViewModel
{
    public ReactiveProperty<string> Input { get; }
    public ReactiveProperty<string> Time { get; }
    public ReactiveCommand UpdateTimeCommand { get; }
    public ReactiveCommand ResetCommand { get; }
    public ReactiveCommand<string> ProcessCommand { get; }

    public ViewModel()
    {
        Input = new ReactiveProperty<string>("");
        Time = new ReactiveProperty<string>();

        // Always executable command
        UpdateTimeCommand = new ReactiveCommand();
        UpdateTimeCommand.Subscribe(_ => Time.Value = DateTime.Now.ToString("HH:mm:ss"));

        // Command with CanExecute based on Input
        ResetCommand = Input
            .Select(x => !string.IsNullOrWhiteSpace(x))
            .ToReactiveCommand()
            .WithSubscribe(() => Input.Value = "");

        // Command with parameter
        ProcessCommand = new ReactiveCommand<string>()
            .WithSubscribe(param => Console.WriteLine($"Processing: {param}"));

        // Command that disables for 5 seconds after execution
        var trigger = new Subject<Unit>();
        var throttledCommand = Observable.Merge(
            trigger.Select(_ => false),
            trigger.Delay(TimeSpan.FromSeconds(5)).Select(_ => true))
            .ToReactiveCommand()
            .WithSubscribe(() => trigger.OnNext(Unit.Default));
    }
}
```

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

### Define MainPage XAML Layout

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/xf.md

Configures the ContentPage to bind the Entry and Label controls to the MainPageViewModel properties.

```xml
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:GettingStartedXF"
             x:Class="GettingStartedXF.MainPage">
    <ContentPage.BindingContext>
        <local:MainPageViewModel />
    </ContentPage.BindingContext>
    <StackLayout>
        <Entry Text="{Binding Input.Value, UpdateSourceEventName=TextChanged}" />
        <Label Text="{Binding Output.Value}" />
    </StackLayout>
</ContentPage>
```

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

### Configure ReactivePropertyMode

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Shows how to disable the initial subscription callback and allow notifications on identical value assignments.

```csharp
var rp = new ReactiveProperty<string>("initial value", mode: ReactivePropertyMode.None);
rp.Subscribe(x => Console.WriteLine(x)); // -> don't output value
rp.Value = "initial value"; // -> initial value
```

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

### Create AsyncReactiveCommand Snippet

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/add-snippets.md

Use this snippet to quickly generate a public AsyncReactiveCommand declaration.

```csharp
public AsyncReactiveCommand CommandName { get; }
```

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

### Create TimerObjectViewModel

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

Wraps the model class into a view model using ReactiveProperty to observe property changes.

```csharp
public class TimerObjectViewModel : IDisposable
{
    public TimerObject Model { get; }

    public ReadOnlyReactiveProperty<string> CountMessage { get; }

    public TimerObjectViewModel(TimerObject timerObject)
    {
        Model = timerObject;
        CountMessage = Model.ObserveProperty(x => x.Count)
            .Select(x => $"Count value is {x}.")
            .ToReadOnlyReactiveProperty();
    }

    public void Dispose()
    {
        Model.Dispose();
    }
}
```

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

### ForceNotify Method

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/ReactiveProperty.md

Explains how to use the ForceNotify method to manually push values and trigger PropertyChanged events.

```APIDOC
## `ForceNotify`

If want to push the value forcibly, then can use the `ForceNotify` method.
This method pushes the value to subscribers, and raise a `PropertyChanged` event.

```csharp
var rp = new ReactiveProperty<string>("value");
rp.Subscribe(x => Console.WriteLine(x));
rp.PropertyChanged += (_, e) => Console.WriteLine($"{e.PropertyName} changed");

rp.ForceNotify();
```

Output is as below.

```
value                  # first subscribe
value                  # by the ForceNotify method
Value changed          # by the ForceNotify method
```
```

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

### UWP XAML Layout

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

XAML markup for displaying a ReactiveCollection in a ListView with a command button.

```xml
<Page x:Class="App1.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:local="using:App1"
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      mc:Ignorable="d">
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <StackPanel Orientation="Horizontal">
            <Button Content="Start"
                    Command="{x:Bind ViewModel.StartRecordCommand}"
                    Margin="5" />
        </StackPanel>
        <ListView ItemsSource="{x:Bind ViewModel.Records}"
                  Grid.Row="1" />
    </Grid>
</Page>
```

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

### Equivalent Collection Filtering Methods

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Collections.md

Demonstrates two equivalent ways to create a filtered read-only observable collection. The second overload allows for custom observation of element updates.

```csharp
collection.ToFilteredReadOnlyObservableCollection(x => x.SomeProperty);
```

```csharp
collection.ToFilteredReadOnlyObservableCollection(x => x.SomeProperty, x => x.PropertyChangedAsObservable());
```

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

### Two-way Synchronization with Convert Logic

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Work-together-with-plane-model-layer-objects.md

Use `ToReactivePropertyAsSynchronized` with `convert` and `convertBack` delegates to transform values during synchronization. The `convert` delegate transforms the POCO value to the `ReactiveProperty` value, and `convertBack` transforms it back.

```csharp
public class ViewModel
{
    public Person Person { get; } = new Person();

    public ReactiveProperty<string> Name { get; }

    public ViewModel()
    {
        Name = Person.ToReactivePropertyAsSynchronized(x => x.Name,
            convert: x => string.IsNullOrWhiteSpace(x) ? "" : $"{x}-san",
            convertBack: x => Regex.Replace(x, "-san$", ""));
    }
}
```

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

### Unsubscribe from ReactiveCommand actions

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/features/Commanding.md

Shows how to manage subscriptions using IDisposable or by disposing the command itself.

```csharp
var command = new ReactiveCommand();
var subscription1 = command.Subscribe(_ => { ... some actions ... });
var subscription2 = command.Subscribe(_ => { ... some actions ... });

// Unsubscribe per Subscribe method.
subscription1.Dispose();
subscription2.Dispose();

// Unsubscribe all
command.Dispose();
```

```csharp
IDisposable subscription = null;
var command = new ReactiveCommand().WithSubscribe(() => { ... some actions ... }, out subscription);

// Unsubscribe
subscription.Dispose();
```

```csharp
var subscriptions = new CompositeDisposable();
var command = new ReactiveCommand()
    .WithSubscribe(() => { ... some actions ... }, subscriptions.Add)
    .WithSubscribe(() => { ... some actions ... }, subscriptions.Add);

// Unsubscribe
subscription.Dispose();
```

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

### Create ReactiveCommand Snippet

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/add-snippets.md

Use this snippet to quickly generate a public ReactiveCommand declaration.

```csharp
public ReactiveCommand CommandName { get; }
```

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

### Create ReactiveProperty Snippet

Source: https://github.com/runceel/reactiveproperty/blob/main/docs/docs/getting-started/add-snippets.md

Use this snippet to quickly generate a public ReactiveProperty declaration.

```csharp
public ReactiveProperty<T> PropertyName { get; }
```