SelectMany observablesを選択する必要があるとき、正しい方法で考えていますか？

Question

したがって、私はSubjectを使用していて、おそらく使用するかどうかわからないので、次のコードに関するいくつかの質問に終わる可能性があります。

これは私が説明するのが難しいです、私はなぜ、私は専門用語が不足しているのかわかりません。

私がしようとしているのは、いくつかのオブザーバブルを登録することができる1つのタイプです。このタイプを渡して、すべてのオブザーバブルをグループ化し、それから単一のオブザーバブルを公開することができます。

だからこれが正しいならば、私の最初の質問は私は正しい方法で物事を考えていないです感覚を得る、私は思っていたか、それをやってより多くの「反応」方法は何ですか？

これは私があなたにオブザーバブルを登録することができるこの型を持っていることです。この同じタイプでも、私が購読することができる単一のオブザーバブルを公開することになります。

ここでは、コード例を少し説明します。 したがって、SomeTypeWithObservableは、公開する多くの種類の1つになる可能性があります。IObservable<SomeEvents> ReactiveTestingタイプは、すべての観測値をまとめて1つのIObservable<SomEvents>を公開するタイプです。それは内部Subject<IObservable<SomeEvents>>に送るRegisterObservableメソッドがあります。コンストラクタは、私がこのサブジェクトのSelectManyであるとして公開したいObservableを設定します。私は観測の登録が使用されていないダミーのサブスクリプションを使用しなかった場合は、以下のインプリメンテーションを使用して

は、私が観察を開始するためにダミーのサブスクリプションで次、SelectMany.Publish.RefCountを実行ReactiveTestingコンストラクタで、私は気づきました。

だから私の2番目の質問が観測を始めるためにダミーのサブスクリプションを持ってOKというコードである、または私は私がちょうど公開から接続していたし、すぐ後にそれを接続したコメントで下にいた何をすべき、または両方とも間違っていて、その場合、誰かが私を正しい方向に向けることができますか？

私の第3の質問件名を使用する必要がありますか？

サブスクリプションよりも先にRegisterObservableと連絡し、ダミーSubscribeまたはConnectを入れないと、トリガーされたイベントは監視されません。

私の第4の質問誰かが後者を説明できますか？ 私は、それがPublishとRefCountであるため、Observableから始まるサブスクリプションがあるまでは何もしないと考えています。

コード

--Edited - だから私の最初の質問は、私が感じIを取得し、私はReactiveTesting

enum SomeEvents 
{ 
    event1, 
    event2, 
    event3, 
    event4 
} 

interface ISomeTypeWithObservable 
{ 
    IObservable<SomeEvents> SomeObservableEvents { get; } 
} 

class SomeTypeWithObservable2 : ISomeTypeWithObservable 
{ 
    private event EventHandler SpecialEvent; 
    public SomeTypeWithObservable2() 
    { 
     var observableFromSpecialEvent = Observable.FromEventPattern(h => SpecialEvent += h, h => SpecialEvent -= h).Select(x => SomeEvents.event2); 
     SomeObservableEvents = Observable.Create<SomeEvents>(observer => 
      { 
       return observableFromSpecialEvent.Subscribe(observer); 
      }) 
      .Publish() 
      .RefCount(); 
    } 

    public IObservable<SomeEvents> SomeObservableEvents { get; } 
    public void TriggerEvent() 
    { 
     SpecialEvent.Invoke(this, new EventArgs()); 
    } 
} 

class SomeTypeWithObservable : ISomeTypeWithObservable 
{ 
    private event EventHandler SpecialEvent; 
    public SomeTypeWithObservable() 
    { 
     var observableFromSpecialEvent = Observable.FromEventPattern(h => SpecialEvent += h, h => SpecialEvent -= h).Select(x => SomeEvents.event1); 
     SomeObservableEvents = Observable.Create<SomeEvents>(observer => 
      { 
       return observableFromSpecialEvent.Subscribe(observer); 
      }) 
     .Publish() 
     .RefCount(); 
    } 

    //Some code in here that will produce things to observe, maybe Observable.FromEventPattern... 
    public IObservable<SomeEvents> SomeObservableEvents { get; } 

    public void TriggerEvent() 
    { 
     SpecialEvent.Invoke(this, new EventArgs()); 
    } 
} 

class ReactiveTesting 
{ 
    private Subject<IObservable<SomeEvents>> _innerEvents = new Subject<IObservable<SomeEvents>>(); 

    public IObservable<SomeEvents> AllEvents; 
    public ReactiveTesting() 
    { 
     AllEvents = _innerEvents.SelectMany(x => x).Publish().RefCount(); 
     AllEvents.Subscribe(next => { }, exception => { },() => { }); 

     //This instead of the above?? 
     //var connectableObservable = _innerEvents.SelectMany(x => x).Publish(); 
     //AllEvents = connectableObservable; 
     //connectableObservable.Connect(); 
    } 

    public void RegisterObservable(ISomeTypeWithObservable someTypeWithObservable) 
    { 
     _innerEvents.OnNext(someTypeWithObservable.SomeObservableEvents); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var reactiveTesting = new ReactiveTesting(); 
     var someTypeWithObservable = new SomeTypeWithObservable(); 
     var someTypeWithObservable2 = new SomeTypeWithObservable2(); 
     reactiveTesting.AllEvents.Subscribe(next => Console.WriteLine(string.Format("Subscriber 1 - {0}", next.ToString("G")))); 
     reactiveTesting.AllEvents.Subscribe(next => Console.WriteLine(string.Format("Subscriber 2 - {0}", next.ToString("G")))); 
     reactiveTesting.RegisterObservable(someTypeWithObservable); 
     reactiveTesting.RegisterObservable(someTypeWithObservable2); 
     someTypeWithObservable.TriggerEvent(); 
     someTypeWithObservable.TriggerEvent(); 
     someTypeWithObservable.TriggerEvent(); 
     someTypeWithObservable2.TriggerEvent(); 
     someTypeWithObservable2.TriggerEvent(); 
     someTypeWithObservable2.TriggerEvent(); 

     Console.WriteLine("Press key..."); 
     Console.ReadLine(); 
    } 
} 

Answer 1

に登録したい観察できる複数がある表示するには の正しいことを考えていないのですが、これが正しいのか、それとももっとあるのでしょうかと私は思っていました。 "反応する"方法ですか？ ReactiveTestingでSubjectを使用して

は通常、あなたが排除、またはアウトさらにプッシュすることができ、いくつかの不可欠のコードを持つきっかけになるものです。周囲のコードの一部を書き直す必要があるかもしれません。

class ReactiveTesting 
{ 
    public IObservable<SomeEvents> AllEvents { get; } 
    public ReactiveTesting(IObservable<IObservable<SomeEvents>> eventSource) 
    { 
     AllEvents = eventSource.Merge().Publish().RefCount(); 
    } 
} 
class Program 
{ 
    public static void Main(string[] args) 
    { 
     var someTypeWithObservable = new SomeTypeWithObservable(); 
     var reactiveTesting = new ReactiveTesting(Observable.Return(someTypeWithObservable.SomeObservableEvents)); 
     reactiveTesting.AllEvents.Subscribe(next => Console.WriteLine(string.Format("Subscriber 1 - {0}", next.ToString("G")))); 
     reactiveTesting.AllEvents.Subscribe(next => Console.WriteLine(string.Format("Subscriber 2 - {0}", next.ToString("G")))); 
     someTypeWithObservable.TriggerEvent(); 
     someTypeWithObservable.TriggerEvent(); 
     someTypeWithObservable.TriggerEvent(); 

     Console.WriteLine("Press key..."); 
     Console.ReadLine(); 

    } 
} 

だから私の2番目の質問は、そのコードが 、観察を始めるためにダミーのサブスクリプションを持つことがOKである、または私は下にやったことを実行する必要があります。この場合、あなたはこのようなものに終わるだろう のコメントでは、パブリッシュから接続可能だったのですが、その後すぐに を接続したか、どちらも間違っていて、 誰かが正しい方向に向いていますか？

これは必須ではありません。それはそれを取り除くのと同じように私のために働く。ダミー登録は.Replay().Refcount()で役立ちます。私は.Publish()の点を見ません。

私の3番目の質問私は科目を使用すべきですか？

これは基本的にコードの匂いです。それを排除するか、ビジネスロジックから離れさせることができれば、より良い結果が得られます。