常連

ご質問させていただきます。よろしくお願いいたします。
[Unity用のRxプラグイン](https://github.com/neuecc/UniRx)を使用させていただき開発しております。その中でストリームの合成がすごく難しくコードが複雑になってしまいこれで正しいのか分からないのでご質問させていただきたいです。

###環境
・Unity 2017.2.0p4
・[UniRx 5.5.0](https://github.com/neuecc/UniRx/releases)

###実装したい処理
1. (初期化) Vector2のデータをランダムに1つ生成
2. (初期化) ランダムに1度00秒遅延させる
3. (開始) UpdateAsObservableでループ開始
4. (判定) 1で生成したデータとオブジェクトの距離が一定の距離になるまで処理を続ける
5. (OnNext) Subscribeで1で生成したデータに徐々に近づける
6. (Oncompleted) 完了後1から繰り返し

###実現したいこと
コードが複雑になっているので簡潔な方法がありましたらご教授いただきたいです。プロパティまたはフィールド(クロージャ)などの外部からの参照無しで実装したいです。言語は問いません。大変お手数ですがよろしくお願いいたします。

###現状のコード
```C#
static readonly float WALK_SPEED = .7f;
static readonly float RAND_INTERVAL_MIN = 4;
static readonly float RAND_INTERVAL_MAX = 10;
static readonly float DISTANCE = .05f;
static readonly Vector2 RAND_POS_LEFT_TOP = new Vector2(-1, 3);
static readonly Vector2 RAND_POS_RIGHT_BOTTOM = new Vector2(-2, 4);
Transform MyTransform;

void Start ()
{
  MyTransform = gameObject.transform;

  Observable.Empty<Vector2>().StartWith(() => GetRandPos())
    .SelectMany(pos => 
      Observable.Timer(TimeSpan.FromSeconds(UnityEngine.Random.Range(RAND_INTERVAL_MIN, RAND_INTERVAL_MAX)))
      .Select(_ => pos)
    )
    .SelectMany(pos => this.UpdateAsObservable().Select(_ => pos))
    .TakeWhile(pos => Vector2.Distance(pos, MyTransform.position) >= DISTANCE)
    .Select(pos => GetNextPos(pos, MyTransform.position))
    .RepeatUntilDestroy(this)
    .Subscribe(pos => MyTransform.position = pos);
}

Vector2 GetNextPos(Vector2 target,Vector2 me)
{
  var rad = Mathf.Atan2(target.y - me.y, target.x - me.x);

  me.x += WalkSpeed * Time.deltaTime * Mathf.Cos(rad);
  me.y += WalkSpeed * Time.deltaTime * Mathf.Sin(rad);
  return me;
}

Vector2 GetRandPos()
{
  var x = UnityEngine.Random.Range(
    RAND_POS_LEFT_TOP.x,
    RAND_POS_RIGHT_BOTTOM.x
  );

  var y = UnityEngine.Random.Range(
    RAND_POS_LEFT_TOP.y,
    RAND_POS_RIGHT_BOTTOM.y
  );

  return new Vector2(x, y);
}
```

[Rx] 効率の良いストリームの合成方法

ゲームのポーズ機能のため、UniRxで実装したタイマーを一時停止／再開させたいのですが、知識不足でキレイな方法が浮かびません。

### 実装コード（Observable）
```C#
public class TimerManager : MonoBehaviour
{
    // 試合開始前のカウントダウン（Observable）
    public IObservable<int> GameStartCountDownObservable => gameStartCountDownObservable.AsObservable();
    private IConnectableObservable<int> gameStartCountDownObservable;

    // 試合中のカウントダウン（Observable）
    public IObservable<int> InPlayCountDownObservable => inPlayCountDownObservable.AsObservable();
    private IConnectableObservable<int> inPlayCountDownObservable;

    // カウントダウン秒数
    public int CountDownTime { get; private set; } = 2;

    // プレイ秒数
    public int PlayTime { get; private set; } = 60;

    void Awake()
    {
        // 試合前のカウントダウンタイマ
        // CountDownTime秒タイマのストリームをPublishでHot変換（まだConnectはしない）
        gameStartCountDownObservable = CreateCountDownObservable(CountDownTime).Publish();

        // 試合中のタイマ
        // PlayTime秒タイマのストリームをPublishでHot変換（まだConnectはしない）
        inPlayCountDownObservable = CreateCountDownObservable(PlayTime).Publish();

        // 3秒タイマのOnCompleteで60秒タイマをConnectする（60秒タイマの起動）
        // おそらく第二引数がコンプリート時のコールバック処理
        gameStartCountDownObservable.Subscribe(_ => {; }, () => inPlayCountDownObservable.Connect());
    }

    // CountTimeだけカウントダウンするストリーム
    private IObservable<int> CreateCountDownObservable(int countTime)
    {
        return Observable
            .Timer(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1))
            .Select(x => (int)(countTime - x))
            .TakeWhile(x => x > 0);
    }

    // カウントダウンを開始
    public void StartCountDown()
    {
        // ゲーム開始前のカウントダウンのタイマ起動
        gameStartCountDownObservable.Connect();
    }
}
```

### 購読側
あとは外部スクリプトで`TimeManager.StartCountDown()`を実行してConnect。
以下のように購読してカウントダウンの秒数を取得しています。

```C#
// Connect
TimeManager.StartCountDown();

// カウントダウンの購読
TimerManager.GameStartCountDownObservable
    .Subscribe(time =>
    {
        Debug.Log(time);
    }, () =>
    {
        // カウントダウンが完了したとき
        // ゲーム開始
        GameManager.StartGame();
    })
    .AddTo(this);
```
---
この状態で
- ポーズボタンを押したらカウントダウンを停止
- 再開ボタンを押したらカウントダウンを再開
したいのですが、上手いやり方が中々思いつきません。

経過秒数を小数点含めて保持しポーズ時にDisposeで破棄、再開時に経過秒数で初期化しConnectする他ないのでしょうか。
ご教授いただけますと幸いです。


UniRxで実装したタイマーを一時停止／再開したい

C#でSystem.Reactive.Linqを用いてリアクティブプログラミングを行なっています。
一つのストリームから発行された値を、Subscribeしてある処理を行なっているのですが、その発行された値によって異なる処理を行いたいと考えています。
```C#
observable.Subscribe(v => {
                   if(v==1) //処理1
                   else //処理2
});
```
こんな感じです(スマホで打っているのでインデントがずれていたら申し訳ありません…)。

これを、Subscribeの中で条件分岐するのではなく、このような感じにすることはできないのでしょうか？
```C#
observable.SubscribeIf(v=>v==1, v=> //処理1)
                 .subscribe(v=>//処理2);
                 
```

Whereによるフィルターでは、2回Subscriveを行うことになるのでなんだか…と思っています。
(実際には、もっと多くの条件分岐を行うので尚更)

何かそう言ったメソッド等は用意されていないのでしょうか。
よろしくお願い致します。

C# Rxで、1つのストリームを条件によって複数Subscribeする方法

【前置き】
MVVMパターンについて勉強をしていると、
従来のイベントハンドラをコードビハインドに記述することが嫌われるという情報をよく目にします。
そのための手段としてCommandをViewModelに実装して、Viewはそれをバインドするのが主流という認識です。

ネットで見かけるサンプルではButtonコントロールが例にあがっており、
ButtonにはCommandプロパティがデフォルトで用意されているので
大抵のサンプルコードは読んで理解ができました。

しかし、いざCanvasコントロールで試してみたところCommandプロパティが無いようでした。

【知りたいこと】
・Commandプロパティが存在しないコントロールはどうやってコードビハインドを避けた実装ができますか。
（Canvasコントロールを継承したクラスを作ってCommandプロパティを自作したり…？）
・一つのコントロールにいくつものCommandを定義することは可能でしょうか。
例えばクリック、ドラッグ、右クリックなどそれぞれのユーザ操作によって処理を分けたいです。

【WPF】【MVVM】CommandをButton以外で使用する方法を知りたい

### 前提・実現したいこと

Reactive Extentionsにて、マウスのシングルクリック（DownとUpの1セット）を取得したいと思っているのですが、
ダブルクリックとの判別ができません。

現状のソースで、ダブルクリックを行うと、シングルクリックが二回が発生したと判断してしまうので、
それをどうにか回避したいです。

1.MouseDownの後、250ms以内にMouseUpしたらイベント発生 ＜ここまでは以下のソース

**2.ダブルクリックと区別するため、さらにそのあと、250ms以内にMouseDownがあったらイベントを発生させない**
この2つ目の実現方法がわからない状態です。

### 該当のソースコード

```C#
            var mouseLeftDown = Observable.FromEvent<MouseButtonEventHandler, MouseButtonEventArgs>(
               h => (s, e) => h(e),
               h => MouseLeftButtonDown += h,
               h => MouseLeftButtonDown -= h);

            var mouseLeftUp = Observable.FromEvent<MouseButtonEventHandler, MouseButtonEventArgs>(
               h => (s, e) => h(e),
               h => MouseLeftButtonUp += h,
               h => MouseLeftButtonUp -= h);

            mouseLeftDown
            .SelectMany(_ => mouseLeftUp
                .TakeUntil(Observable.Timer(TimeSpan.FromMilliseconds(250.0))))
            .Subscribe(x => {
                System.Diagnostics.Debug.WriteLine("single click");
            });

```

### 試したこと
・MouseButtonEventArgsのClickCountで判断 常に１で変化なし
・後ろに.Throttle(TimeSpan.FromMilliseconds(250.0))をつけるとダブルクリック時に1回だけイベントが発生

mouseLeftDownをBuffer(Timespan)でためて、カウントしてみたのですが、クリック数は取れるのですが、Upとセットじゃないのと、クリック数のカウントが安定しないため使えませんでした。
```C#
                .Buffer(TimeSpan.FromMilliseconds(250.0))
                .Select(x => x.Count())
                .DistinctUntilChanged()
```

いただいた情報をもとにそのまま移植してみたところ、クリック数は安定しているようです。
ただ、Upとセットじゃないので、もう少し工夫が必要そうです。
```C#
          int count = 0;
            mouseLeftDown
            .Select(x => count +=1)
            .Throttle(TimeSpan.FromMilliseconds(500.0))
            .Do(x => count = 0)
            .Subscribe(q => {
                System.Diagnostics.Debug.WriteLine("single click:" + q.ToString());
            });
```

### 補足情報（FW/ツールのバージョンなど）

・.Net Flamework 4.7.2
・WPFアプリケーション

【C#】【Rx】Reactive Extentionsにて、マウスのシングルクリック ダブルクリックの判断

最近UniRXを勉強している者です。
Subscribeのネストの際の書き方について、どなたかご教授いただけますと幸いです・・・。

・Fetchはサーバーとの通信です。
・PlayerとPlayerQuestはサーバー側でマージすることはできず、それぞれ取得する必要があります。

```
Player.Fetch()
	.Do(playerData => {
		setPlayerData(playerData);
	})
	.Do(playerData => {
		PlayerQuest.Fetch(playerData).Subscribe(playerQuestData =>{			
			setPlayerQuestData(playerQuestData);
			OpenWindow(playerData, playerQuestData);
		});
	})
	.Subscribe();
```

上記のような場合Subscribeをネストするのは良くない気がしていて、
Player.Fetch()とPlayerQuest.Fetch(playerData)をマージできればと考えているのですが良い書き方がなかなか思いつかないです。
また分けた場合のplayerData、playerQuestDataのOpenWindowへの渡し方がわかっていないです。

PlayerQuest.Fetch(playerData)をPlayer.Fetch().Subscribeの発火に混ぜると
Do(playerData => {OpenWindow(playerData,playerQuestData);}にplayerQuestDataが使えなかったり。

OpenWindow(p);はPlayerQuest.Fetch(playerData)の後に起こってほしいため、
ネストするしか思いつかず現在の状態のように見た目もよろしくなくなってしまいます。

わかりにくいかもしれませんが、よろしくお願い致します。

UniRxのSubscribeのネストのリファクタについて

.NET 3.5 にて
Install-Package Rx-Main -Version 1.0.11226
System.Reactive を利用しています。

A,B,C,ZをそれぞれCold Observableとしたときに
A -> B-> C のObservableチェインで成否に関わらず、最後に必ずZの実行を保証したい。
Zは非同期で Zの完了を待って SubsribeのOnComplete/OnErrorを処理したい。
```
A
.SelectMany( n => B)
.SelectMany( n => C)
.?????(()=>{
     //後始末を実行した後で OnComplete/OnErrorを処理したい
})
.Subscribe( n => {}, error => {}, () =>{ })

```
後始末処理はFinallyを使った場合、OnCompleteとOnErrorの後に処理されてしまいます。
どういう書き方ができますでしょうか。

Subscribeをネストさせた書き方は避けたいです。
###避けたいコード
```
Observable.Crate( observer => {

A
.SelectMany( n => B)
.SelectMany( n => C)
.Finally(()=>{
     z.Finally(()=> {
        Subscribeのキャッシュで observer.OnNext/OnErrorを発火
     }
})
.Subscribe( n => { //nをキャッシュ
 }, error => { //errorをキャッシュ
 }, () =>{ });

return Disposable.Empty;
})
.Subscribe( n => {}, error => {}, () =>{ });
```

###Finallyを使いたくない理由
Subscribeにて、どういう処理がされるのか分からず（ShowDialogなど）、後始末が遅れてしまうのを避けたい

###ネストしたくない理由
単純にかっこ悪いので。
Observableを繋いで新しいObservableを生成することがRxの醍醐味で
Subscribeにて１回イベントストリームが流れるのがColdなので、
Subscribeを何回も内部で行うのは、Rxの思想に反すると思うから。

System.ReactiveでOnComplete/OnError前に確実に実行されるObservableを挟みたい

Rxの勉強をしており、.NETのイベントハンドラ（今回はMouseMoveイベント）を、
IObservableシーケンスに変換してくれるFromEventメソッドの理解を深めようとしています。
ネットのサンプルコードを見ていると以下のようなコードによく出くわします。
```
IObservable<MouseEventArgs> mouseMove = Observable.FromEvent<MouseEventHandler, MouseEventArgs>(
        h => (s, e) => h(e),
        h => this.MouseMove += h,
        h => this.MouseMove -= h);
```
これはFromEventメソッドの中でも下記オーバーロードを利用している認識です。
```
IObservable<TEventArgs> FromEvent<TEventHandler, TEventArgs>(
　　　Func<Action<TEventArgs>, TEventHandler> conversion,
　　　Action<TEventHandler> addHandler,
　　　Action<TEventHandler> removeHandler)
```

この３つの引数とサンプルコードの引数がどのように対応しているのかを教えていただきたいです。
現段階では引数１：conversionについて考えて迷路に迷い込んでいる状態です。
仰々しく書くと
**『引数convserionに「イベント情報（TEventArgs）を引数として受け取るデリゲート（Action）」を渡してください。戻り値でイベントハンドラ（TEventHandler）を返却します。』**
という理解なのですが、それがなぜhだのsだのeだので表現出来ているのかが謎です。
どなたか分かりやすくご説明いただけないでしょうか？

Rx.NET