常連

Angularを使ってとある画面を作成していた際に、
RxJSを使ってどのように実現すればよいか悩んでおり質問させてください。

### 前提・実現したいこと

要件としては以下の2件があります。
0. 画面上に「入力項目A」と「入力項目B」があり、いずれかの値が書き換えられると、双方の入力されている値を元に処理を行う。
0. URLパラメータを指定して画面を表示することができ、画面の表示時にパラメータの値を「入力項目A」と「入力項目B」に設定し、かつ2つのパラメータの値を元に処理を行う。


(1)を実現する方法としては、RxJSのCombineLatestを使えばよさそうだなと思い、以下のような感じで実装を進めました。
```
inputA = new BehaviorSubject<string>('');
inputB = new BehaviorSubject<string>('');

CombineLatest(inputA, inputB)
  .pipe(flatMap(2つの値を元にした処理))
```

このとき、画面での操作では「入力項目A」と「入力項目B」に、**同時**に入力することはないため、期待通りの動作が実現できました。

しかしながら、要件(2)のように、『「入力項目A」と「入力項目B」に**同時**に値を設定する』となったときに、単純にURLパラメータ取得後に以下のような呼び出しを行った場合...
```
inputA.next(queryParam.input_a);
inputB.next(queryParam.input_b);
```
`inputA.next()`を行った時点で、CombineLatestが流れ、
続いての`inputB.next()`で、ふたたびCombineLatestが流れることになります。


実現したいこととして、上記のように2つの要素の値が同時に指定された際には、1度の処理だけで済ませておきたいと考えています。

zipオペレータを使えば回避できるのではと考えましたが、そうすると今度は、画面から入力した際に、「入力項目A」と「入力項目B」の両方を変えなければ、値が流れないので使えなさそうです。

このように、「入力項目」に個別に値を設定した場合、同時に値を設定したい場合、の両方の要件をRxJSを使って満たす実装方法というのはあるのでしょうか？

RxJSで2つの値が同時に変えられた場合の処理方法について

### 前提・実現したいこと

ReactivePropertyを使用して複数のチェックボックスのうちどれかがOnのときにTrueになるReactiveProperty<bool>と、
実行できるReactiveCommandを作成したいです。

### 該当のソースコード

```CSharp
static class Model{
    public static ReactiveProperty<List<Check>> BaseCheckItems {get;}
        = new ReactiveProperty<List<Check>>( new List<Check>(){ new Check(), new Check() } );
}

class ViewModel {
    public ViewModel() {
        this.CheckItems = Model.BaseCheckItems.ToReactiveProperty();
        this.AnyChecked = this.CheckItems.Value
                             .Select( x => x.IsChecked )
                             .CombineLatest( x => x.Any( z => z ) )
                             .ToReactiveProperty();

        this.ButtonCommand = this.AnyChecked.ToReactiveCommand();
    }
    public ReactiveProperty<List<Check>> CheckItems {get;}
    public ReactiveProperty<bool> AnyChecked {get;}
    public ReactiveCommand ButtonCommand {get;}
}

public class Check {
    public ReactiveProperty<bool> IsChecked {get;} = new ReactiveProperty<bool>();
}
```

```Xml
// 細かい内容は略します
<Window DataContext=(ViewModel)>
  <StackPanel>
    <ItemsControl ItemsSource="{Binding CheckItems.Value}">
      <ItemsControl.ItemTemplate>
        <DataTemplate>
          <CheckBox IsChecked="{Binding IsChecked.Value}">
        </DataTemplate>
      </ItemsControl.ItemTemplate>

      <Button Command="{Binding ButtonCommand}"/>
  </StackPanel>
</Window>
```

### 発生している問題・エラーメッセージ
this.AnyChecked = this.CheckItems.Value としているため、以下の処理を行うとAnyCheckedの通知?が来なくなってしまいます。
```CSharp
Model.BaseCheckItems.Value = new List<Check>(){ new Check() };
```
this.CheckItems.Valueを変更してもAnyCheckedに通知が来るようにはどのように書いたら良いでしょうか？

### 補足情報（FW/ツールのバージョンなど）
VisualStudio2017 C# WPF
ReactiveProperty 4.1.1

ReactiveProperty<List<ReactiveProperty>>で内部のReactivePropertyをまとめたい

`T`は`INotifyPropertyChanged`を実装している任意の型です。
`ObservableCollection<T>`に格納されているデータについて、条件を満たす場合に`true`、満たさない場合に`false`を発行する`IObservable<bool>`(正確には`ReadOnlyReactiveProperty<bool>`)を作りたいです。
簡単にできると思ったのですがやり方がわからなかったので、わかる方は教えていただければ幸いです。

```C#
public class MyData : BindableBase
{
    public string Id { get => _id; set => SetProperty(ref _id, value); } 
    private string _id;
}

public class MyDataUserViewModel
{
    // 例：2文字以上の場合true
    public ReactiveProperty<bool> IsLargeLength { get; }
    public MyDataUserViewModel()
    {
        // 変換したいデータのObservableCollection
        var collection = new ObservableCollection<MyData>();
        collection.AddRange(Enumerable.Range(1, 10).
            Select(i => new MyData { Id = i.ToString() }).ToArray());

        // うまくいかなかった例
        // Anyの時点でboolになるのでダメ
        IsLargeLength = collection.Any(d => d.Length >= 2).ToReadOnlyReactiveProperty();
        // これだとReadOnlyにならない
        IsLargeLength = collection.
            ToReactivePropertySlimAsSynchronized(c => c.Any(d => d.Length >= 2));
    }  
}
```

---
言語：C# 9.0

ObservableCollection<T>からIObservable<bool>/ReactiveProperty<bool>を作りたい

### 前提・実現したいこと

Reactive Extensionsで入力→変換→出力の"変換"の部分で非同期メソッドを使用するが、それを再入せず、順番に実行したいです。
また、変換→出力部分を後で停止できるようにもしたいです。

ここではサンプルとして、1秒毎に値を発行する`Observable.Interval`を入力、文字列への変換をするメソッド`ConvertAsync`を変換、時刻などを付加してコンソールへプリントするメソッド`WriteLineDebug`を出力としています。

変換メソッド`ConvertAsync`は内部で`await Task.Delay`をしていますが、実際に使用する場合はここがファイルやネットワークアクセスになります。
この`ConvertAsync`の開始・終了が前後しないように順番に行いたいです。

### 発生している問題・エラーメッセージ
#### SelectManyの場合

変換メソッドを`SelectMany`で呼んだ場合、変換メソッド`ConvertAsync`の順番が前後してしまいます。
ただし、変換→出力部分の停止はできています。

以下では0~3個目までは問題ないですが、3個目の開始`Start ConvertAsync 3`の後に、3個目の完了`End ConvertAsync 3`前に4個目が開始`Start ConvertAsync 4`してしまいます。


出力結果
```
00.065|Thread:1|Start Subscription
00.615|Thread:5|Start ConvertAsync 0
00.745|Thread:4|End   ConvertAsync 0
00.750|Thread:6|Subscrive inputValue:[Converted:0 delayMilliSec:100]
01.100|Thread:6|Start ConvertAsync 1
01.210|Thread:6|End   ConvertAsync 1
01.210|Thread:5|Subscrive inputValue:[Converted:1 delayMilliSec:100]
01.600|Thread:4|Start ConvertAsync 2
01.710|Thread:5|End   ConvertAsync 2
01.710|Thread:4|Subscrive inputValue:[Converted:2 delayMilliSec:100]
02.102|Thread:5|Start ConvertAsync 3
02.597|Thread:5|Start ConvertAsync 4
02.838|Thread:5|End   ConvertAsync 3
02.839|Thread:4|Subscrive inputValue:[Converted:3 delayMilliSec:723]
03.107|Thread:4|Start ConvertAsync 5
03.605|Thread:5|Start ConvertAsync 6
04.105|Thread:4|Start ConvertAsync 7
04.115|Thread:4|End   ConvertAsync 4
04.115|Thread:4|Subscrive inputValue:[Converted:4 delayMilliSec:1513]
04.145|Thread:4|End   ConvertAsync 5
04.145|Thread:4|Subscrive inputValue:[Converted:5 delayMilliSec:1029]
04.575|Thread:4|End   ConvertAsync 6
04.575|Thread:4|Subscrive inputValue:[Converted:6 delayMilliSec:948]

04.605|Thread:1|Dispose Subscription
04.605|Thread:5|Start ConvertAsync 8
06.090|Thread:5|End   ConvertAsync 7
06.289|Thread:5|End   ConvertAsync 8
```

#### Scan+Concatの場合

変換メソッドを`Scan+Concat`で呼んだ場合、変換メソッド`ConvertAsync`の順番は保たれますが、
変換部分がすぐ停止しません。出力部分だけがすぐ停止されます。

以下では5個目完了ぐらいのタイミングで停止処理`disposerA.Dispose()`しても、12個目まで変換は続きます。
大体止めた個数の倍ぐらいまで変換が続くようです。20個目で停止→40個目ぐらいまで変換される。

出力結果
```
00.065|Thread:1|Start Subscription
00.613|Thread:4|Start ConvertAsync 0
00.745|Thread:4|End   ConvertAsync 0
00.751|Thread:5|Subscrive inputValue:[Converted:0 delayMilliSec:100]
01.121|Thread:5|Start ConvertAsync 1
01.233|Thread:5|End   ConvertAsync 1
01.233|Thread:5|Subscrive inputValue:[Converted:1 delayMilliSec:100]
01.614|Thread:6|Start ConvertAsync 2
01.725|Thread:4|End   ConvertAsync 2
01.725|Thread:4|Subscrive inputValue:[Converted:2 delayMilliSec:100]
02.112|Thread:4|Start ConvertAsync 3
03.978|Thread:6|End   ConvertAsync 3
03.979|Thread:6|Start ConvertAsync 4
03.979|Thread:5|Subscrive inputValue:[Converted:3 delayMilliSec:1858]
05.823|Thread:7|End   ConvertAsync 4
05.823|Thread:7|Start ConvertAsync 5
05.823|Thread:6|Subscrive inputValue:[Converted:4 delayMilliSec:1836]

06.920|Thread:1|Dispose Subscription
07.223|Thread:4|End   ConvertAsync 5
07.223|Thread:4|Start ConvertAsync 6
08.545|Thread:6|End   ConvertAsync 6
（略）
15.244|Thread:4|Start ConvertAsync 12
16.961|Thread:6|End   ConvertAsync 12
```

### 該当のソースコード

```csharp
class Program
{
    static Random rand = new Random();
    static Stopwatch stopwatch = new Stopwatch();

    static async Task Main(string[] args)
    {
        stopwatch.Start();

        //[入力]　500msec間隔で{0,1,2,3,4,5,6,,,}と流れてくる
        var timer = Observable.Interval(TimeSpan.FromMilliseconds(500));

        WriteLineDebug($"Start Subscription");

        var disposerA = timer
        //[変換] 文字列に変えるが、3個目以降は遅くなる
        //Case1-SelectMany
        .SelectMany(l => ConvertAsync(l))
        //Case2-Scan+Concat
        //.Scan(Task.FromResult(""), async (previousTask, l) =>
        //{
        //    await previousTask.ConfigureAwait(false);
        //    return await ConvertAsync(l).ConfigureAwait(false);
        //})
        //.Concat()

        //[出力] 現在時刻などを追加してプリント
        .Subscribe(x =>
            WriteLineDebug($"Subscrive inputValue:[{x}]"));

        //Enter押下したら、購読を停止
        Console.ReadLine();

        WriteLineDebug("Dispose Subscription");
        disposerA.Dispose();

        //停止を確認
        Console.ReadLine();
    }

    private async static Task<string> ConvertAsync(long l)
    {
        WriteLineDebug($"Start ConvertAsync {l}");

        //実際はファイルアクセスやネットワークアクセスがあるとする
        int delayMilliSec = l >= 3 ? rand.Next(600, 2000) : 100;
        await Task.Delay(delayMilliSec).ConfigureAwait(false);

        WriteLineDebug($"End   ConvertAsync {l}");

        return $"Converted:{l} delayMilliSec:{delayMilliSec}";
    }

    private static void WriteLineDebug(string message) =>
        Console.WriteLine($"{stopwatch.ElapsedMilliseconds * 0.001:00.000}|Thread:{Thread.CurrentThread.ManagedThreadId}|{message}");
}
```


### 試したこと

以下のブログの目次を参考に、`Switch()`、スケージューラーの固定を検討しましたが、期待した動作にはなりませんでした。
[Reactive Extensions再入門](https://blog.okazuki.jp/entry/20120324/1330956809)

### 補足情報（FW/ツールのバージョンなど）
C# 8.0
.NET 5.0
"System.Reactive" Version="5.0.0"
VisualStudio 2019

[C#]Reactive Extensionsでasyncメソッドを順番に実行したい

WPFのDataGridに独自型をバインドし、`AutoGenerateColumn`を`true`に設定しています。このデータの特定列を非表示にしたいため、`AutoGeneratingColumn`イベントをViewModelでハンドルして非表示にすることを考えました。
そこで`EventToReactiveCommand`をxamlに記述したのですが、このコマンドの`Subscribe`が実行されません。コードビハインドでハンドルするとイベント自体は起きているようなのですが、なぜVM側で購読がうまくできないんでしょう？

xaml
```xaml
<Window x:Class="BlankCoreApp1.Views.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:prism="http://prismlibrary.com/"
        xmlns:local="clr-namespace:BlankCoreApp1"
        xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:rp="clr-namespace:Reactive.Bindings.Interactivity;assembly=ReactiveProperty.WPF"
        prism:ViewModelLocator.AutoWireViewModel="True"
        Title="{Binding Title}" Height="350" Width="525" >
    <Grid>
        <DataGrid ItemsSource="{Binding MyData}" AutoGenerateColumns="True" 
                  AutoGeneratingColumn="DataGrid_AutoGeneratingColumn"
                  AutoGeneratedColumns="DataGrid_AutoGeneratedColumns"
                  >
            <i:Interaction.Triggers>
                <i:EventTrigger EventName="AutoGeneratingColumn">
                    <rp:EventToReactiveCommand Command="{Binding AutoGeneratingColumnCommand}">
                        <local:DataGridAutoGeneratingColumnEventConverter/>
                    </rp:EventToReactiveCommand>
                </i:EventTrigger>
            </i:Interaction.Triggers>
        </DataGrid>
    </Grid>
</Window>
```
Viewのコード
```c#
using System.Windows;

namespace BlankCoreApp1.Views
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            System.Diagnostics.Debug.WriteLine(nameof(MainWindow));
            InitializeComponent();
            System.Diagnostics.Debug.WriteLine(nameof(InitializeComponent));
        }

        private void DataGrid_AutoGeneratingColumn(object sender, System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e)
        {
            System.Diagnostics.Debug.WriteLine(e.Column.Header.ToString());
        }

        private void DataGrid_AutoGeneratedColumns(object sender, System.EventArgs e)
        {
            System.Diagnostics.Debug.WriteLine(nameof(DataGrid_AutoGeneratedColumns));
        }
    }
}
```
ViewModelのコード
```c#
using Prism.Mvvm;
using Reactive.Bindings;
using System.Windows.Controls;
using System.Collections.ObjectModel;
using System.Linq;

namespace BlankCoreApp1.ViewModels
{
    public class MainWindowViewModel : BindableBase
    {
        private string _title = "Prism Application";
        public string Title
        {
            get { return _title; }
            set { SetProperty(ref _title, value); }
        }

        public ReactiveCollection<MyDataClass> MyData { get; } 
        public ReactiveCommand<DataGridColumn> AutoGeneratingColumnCommand { get; }
        public MainWindowViewModel()
        {
            System.Diagnostics.Debug.WriteLine(nameof(MainWindowViewModel));
            MyData = new ReactiveCollection<MyDataClass>();
            MyData.AddRange(Enumerable.Range(1, 10).Select(_ => new MyDataClass("a", "b", "C")).ToArray());
            AutoGeneratingColumnCommand = new ReactiveCommand<DataGridColumn>().
                WithSubscribe(c =>
                {
                    // ここに来ない
System.Diagnostics.Debug.WriteLine(nameof(AutoGeneratingColumnCommand));
                });
        }
    }
}
```
データとイベントのコンバーター
```c#
using Reactive.Bindings.Interactivity;
using System;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Controls;

namespace BlankCoreApp1
{
    public class DataGridAutoGeneratingColumnEventConverter : ReactiveConverter<DataGridAutoGeneratingColumnEventArgs, DataGridColumn>
    {
        protected override IObservable<DataGridColumn> OnConvert(IObservable<DataGridAutoGeneratingColumnEventArgs> source)
        {
            System.Diagnostics.Debug.WriteLine(nameof(DataGridAutoGeneratingColumnEventConverter));
            return source.Select(s => s.Column);
        }
    }

    public record MyDataClass(string Id, string Address, string HideColumn);
}
```

目的
---
VMでやりたい理由は以下です。
* `AutoGenerateColumn`を`false`にするのは、開発中にデータ項目が増えたり減ったりするたびにxamlの列定義をいじりたくないためやりたくない
* バインドしているデータは表示にしか使わないためVMの内部クラスとしたいので、コードビハインドで列インデックスや列名指定をしたくない

環境
---
C# 9.0 / NET 5.0
ReactiveProperty / ReactiveProperty.WPF は version 7.11

DataGridのAutoGeneratingColumnイベントをEventToReactiveCommandで購読できない

`T`について特定の条件を満たす要素は重複とみなして除外した`ReactiveCollection`を作りたいです。以下のコードでは重複を除外した`Address`のコレクションを取得したいと思っています。
いくつか試したのですが、コレクションの変更の通知がうまく行われず0件のままになったりデータが重複したりします。どなたかいい実装方法を教えていただければ幸いです。

```c#
public record Sample(string Id, string Address);
public class Comp : IEqualityComparer<Sample>
{
    public bool (Sample? x, Sample? y) => x?.Address == y?.Address;
    public int GetHashCode([DisallowNull] Sample obj) => obj.GetHashCode();
}

// 適当なデータ 
// コンストラクタでToReactiveCollectionしたあとにdataの中身が複数件まとめてセットされる
ObservableCollection<Sample> data;

// ダメな例1 -> Selectの時点でIEnumerable<string>になるためToReadOnlyReactiveCollectionできない
data.Select(x => x.Address).Distinct().ToReadOnlyReactiveCollection();
// ダメな例2 -> Distinctの時点でIEnumerable<Sample>になる
data.Distinct(new Comp()).ToReadOnlyReactiveCollection(x => x.Address);
// ダメな例3 -> ToObservableしても変更は通知されない
data.ToObservable().Select(x => x.Address).Distinct().ToReadOnlyReactiveCollection();
// ダメな例4 -> コレクションのAddのたびに走るため件数がおかしくなる
data.CollectionChangedAsObservable().
    SelectMany(_ => data.Select(x => x.Address).Distinct()).
    ToReadOnlyReactiveCollection();
```

環境
---
c# 9.0

ObserveCollection<T>/ReadOnlyReactiveCollection<T>から重複を除いたReadOnlyReactiveCollection<string>を作りたい

### 実現したいこと

ボタンを押すと、画面に文字が更新されるようにしたいのですが、思うように動きません。
不勉強ながら、アドバイスなどいただけますと幸いです。

### 前提
言語：C＃（wpfを使用）

### 該当のソースコード

```c#
public class ViewModel
{      
    public ReactiveCommand Command { get; }
    public ReactivePropertySlim<string> Message { get; } = new ReactivePropertySlim<string>("1");

    public ViewModel()
    {
        Command = new ReactiveCommand().WithSubscribe(() => OnClick());
        Message.Value = "2";
    }

    private void OnClick(){
        Message.Value = "3";
        Console.WriteLine(Message.Value);
    }
}

```

UI画面では、ボタンに「Command」、ラベル（文字）に「Message」がバインドされています。

### 問題

初期状態は、画面のラベルに「2」が表示されます。
ボタンを押すと、コンソールには「3」が表示されますが、画面のラベルは「2」のままです。
ボタンを押して、画面のラベルの表示を「3」させたいと考えています。
（ボタンを何度おしても、画面のラベルの表示は「2」のままです。）

### その他
質問のタグ等、誤っている場合はすみません！

ReactivePropertyの更新が画面に反映されない

購入したAssetに以下のようなEventがあります。
色々調べてObservable.FromEventなどを試していますが、コンパイルエラーが解決できません。

・購入したAssetのValueChangedというイベント（このようなイベントが他に大量にある）

```ここに言語を入力
ストリーム化したいイベント
 playerCombatant.Status[MyGame.CombatantStatusValue.HP].ValueChanged

ValueChangedの定義部分
    public class StatusValue : ISaveData
        public event NotifyCombatantInt2 ValueChanged;

NotifyCombatantInt2の定義部分
    public delegate void NotifyCombatantInt2(Combatant combatant, int id, int change);
```

これをFromEventでストリーム化出来るのかと、例えば以下の様に試したりしていますがSystem.Actionにする書き方（そもそもする必要があるか？）が分からずコンパイルが通りません。

```ここに言語を入力
        Observable.FromEvent<NotifyCombatantInt2>(
            h => playerCombatant.Status[MyGame.CombatantStatusValue.HP].ValueChanged += h,
            h => playerCombatant.Status[MyGame.CombatantStatusValue.HP].ValueChanged -= h
            ).Subscribe・・・
```
後々UniRXのオペレータでストリームを加工して使っていきたいので、このような購入Assetにあるイベントをストリーム化する方法を理解しておきたいです。

よろしくお願いいたします。

ReactiveX