C# 将可观察的插入到另一个可观察的

假设[伪]代码：

class MyActivity : Activity {

   Observable<string> mainObl

   void OnCreate(Bundle bundle) {
      mainObl = Observable.Never<string>();
   }


   Disposable subscription;

   void OnStart() {
      subscription = mainObl.Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }


   // on click - start filling existing Observable with data from another source
   void OnButtonClick() {
      var tmpObl = Observale.just(1,2,3,4);
      mainObl.WhatMethodHere(tmpObl); // <<<<<<<<<<<< see Q
   }

}

class MyActivity : Activity {

   IDisposable subscription;

   void OnStart() {
      subscription = Observable
          // Adapt a delegate to the event signature and subscribe to the event (unsubscribing when subscription disposed)
          .FromEventPattern<EventHandler,EventArgs>(handler => (s,e) => handler(e), handler => button1.TouchUpInside += handler, handler => button1.TouchUpInside -= handler)               
          // Emit a new observable containing the data "from another source"
          .Select(args => Observable.Return("1", "2", "3", "4"))
          // Dispose any subscription to the previous observable and subscribe to the new observable emitted from above           
          .Switch()
          .Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }
}

类MyActivity:Activity{
可观测主目标
创建时无效（捆绑）{
mainObl=可观察的。从不（）；
}
一次性认购；
void OnStart（）{
subscription=mainObl.subscripte（updateionEvent）；
}
void OnStop（）{
subscription.Dispose（）；
}
//单击-开始用另一个源的数据填充现有的Observable
void OnButtonClick（）{
var tmpObl=观测值（1,2,3,4）；
mainObl.WhatMethodHere（tmpObl）；//最简洁的方法是将所有内容都保留在可观察的空间中，而不是尝试将事件和可观察的代码混合在一起。假设您的按钮名为“button1”，则可以通过以下[伪]代码实现这一点：

class MyActivity : Activity {

   Observable<string> mainObl

   void OnCreate(Bundle bundle) {
      mainObl = Observable.Never<string>();
   }


   Disposable subscription;

   void OnStart() {
      subscription = mainObl.Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }


   // on click - start filling existing Observable with data from another source
   void OnButtonClick() {
      var tmpObl = Observale.just(1,2,3,4);
      mainObl.WhatMethodHere(tmpObl); // <<<<<<<<<<<< see Q
   }

}

class MyActivity : Activity {

   IDisposable subscription;

   void OnStart() {
      subscription = Observable
          // Adapt a delegate to the event signature and subscribe to the event (unsubscribing when subscription disposed)
          .FromEventPattern<EventHandler,EventArgs>(handler => (s,e) => handler(e), handler => button1.TouchUpInside += handler, handler => button1.TouchUpInside -= handler)               
          // Emit a new observable containing the data "from another source"
          .Select(args => Observable.Return("1", "2", "3", "4"))
          // Dispose any subscription to the previous observable and subscribe to the new observable emitted from above           
          .Switch()
          .Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }
}

类MyActivity:Activity{
可授权订阅；
void OnStart（）{
订阅=可观察
//使委托适应事件签名并订阅事件（在释放订阅时取消订阅）
.FromEventPattern（handler=>（s，e）=>handler（e），handler=>button1.TouchUpInside+=handler，handler=>button1.TouchUpInside-=handler）
//发出一个新的可观测数据，其中包含“来自另一个来源”的数据
.Select（args=>Observable.Return（“1”、“2”、“3”、“4”））
//处置对先前可观测数据的订阅，并订阅从上面发出的新可观测数据
.Switch（）
.订阅（更新事件）；
}
void OnStop（）{
subscription.Dispose（）；
}
}

希望能有所帮助。
最简洁的方法是将所有内容都保留在可观察的空间中，而不是尝试将事件和可观察的代码混合在一起。假设您的按钮名为“button1”，您可以通过以下[伪]代码实现这一点：

class MyActivity : Activity {

   Observable<string> mainObl

   void OnCreate(Bundle bundle) {
      mainObl = Observable.Never<string>();
   }


   Disposable subscription;

   void OnStart() {
      subscription = mainObl.Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }


   // on click - start filling existing Observable with data from another source
   void OnButtonClick() {
      var tmpObl = Observale.just(1,2,3,4);
      mainObl.WhatMethodHere(tmpObl); // <<<<<<<<<<<< see Q
   }

}

class MyActivity : Activity {

   IDisposable subscription;

   void OnStart() {
      subscription = Observable
          // Adapt a delegate to the event signature and subscribe to the event (unsubscribing when subscription disposed)
          .FromEventPattern<EventHandler,EventArgs>(handler => (s,e) => handler(e), handler => button1.TouchUpInside += handler, handler => button1.TouchUpInside -= handler)               
          // Emit a new observable containing the data "from another source"
          .Select(args => Observable.Return("1", "2", "3", "4"))
          // Dispose any subscription to the previous observable and subscribe to the new observable emitted from above           
          .Switch()
          .Subscribe(UpdateUiOnEvent);
   }

   void OnStop() {
      subscription.Dispose();
   }
}

类MyActivity:Activity{
可授权订阅；
void OnStart（）{
订阅=可观察
//使委托适应事件签名并订阅事件（在释放订阅时取消订阅）
.FromEventPattern（handler=>（s，e）=>handler（e），handler=>button1.TouchUpInside+=handler，handler=>button1.TouchUpInside-=handler）
//发出一个新的可观测数据，其中包含“来自另一个来源”的数据
.Select（args=>Observable.Return（“1”、“2”、“3”、“4”））
//处置对先前可观测数据的订阅，并订阅从上面发出的新可观测数据
.Switch（）
.订阅（更新事件）；
}
void OnStop（）{
subscription.Dispose（）；
}
}

希望能有所帮助。
如果我想让您的代码保持与现在相同的结构，我会这样做：

class MyActivity
{
    private Subject<IObservable<string>> mainObl;
    private IDisposable subscription = null;

    public void OnCreate()
    {
        mainObl = new Subject<IObservable<string>>();
    }

    public void OnStart()
    {
        subscription = mainObl.Merge().Subscribe(x =>
        {
            Console.WriteLine(x);
        });
    }

    public void OnStop()
    {
        subscription.Dispose();
    }

    public void OnButtonClick()
    {
        var tmpObl = new [] { 1, 2, 3, 4 }
            .Select(x => x.ToString())
            .ToObservable();
        mainObl.OnNext(tmpObl);
    }
}

…你会发现：

1
2
3
4
1.
2.
3.
4.
如果我想让您的代码保持与现在相同的结构，我会这样做：

class MyActivity
{
    private Subject<IObservable<string>> mainObl;
    private IDisposable subscription = null;

    public void OnCreate()
    {
        mainObl = new Subject<IObservable<string>>();
    }

    public void OnStart()
    {
        subscription = mainObl.Merge().Subscribe(x =>
        {
            Console.WriteLine(x);
        });
    }

    public void OnStop()
    {
        subscription.Dispose();
    }

    public void OnButtonClick()
    {
        var tmpObl = new [] { 1, 2, 3, 4 }
            .Select(x => x.ToString())
            .ToObservable();
        mainObl.OnNext(tmpObl);
    }
}

…你会发现：

1
2
3
4
1.
2.
3.
4.
但是你必须问，为什么它是
主题
而不是
主题
。我必须问，为什么要使用主题？它添加了更多代码，增加了一个忘记处理的地方（本例中未处理主题），因此，虽然这为OP提供了一个有用的垫脚石，但另一个答案要好得多。@LeeCampbell-OP专门询问在第一个订阅后如何将一个可观察对象注入到另一个中-在这种情况下，它不能是
主题。另一个答案甚至不编译。@LeeCampbell-另外，
OnButtonClick
可能是也可能不是真正的事件处理程序。它肯定没有正确的签名。我已经回答了这个问题，考虑了所有这些因素，并提供了最直接的答案。OP还声明他们是RX的初学者，因此可能不知道如何提出如何正确实现预期行为的问题.@ibebbs-这也是我在这里给出尽可能直接的答案的另一个原因。但是你必须问，为什么它是
主题
，而不是
主题
。然后我必须问，为什么要使用主题？它添加了更多的代码，增加了一个忘记处理的地方（在本例中，主题没有被处理），因此，虽然这为OP提供了一个有用的垫脚石，但另一个答案要好得多。@LeeCampbell-OP专门询问在第一个订阅后如何将一个可观察对象注入到另一个中-在这种情况下，它不能是
主题。另一个答案甚至不编译。@LeeCampbell-另外，
OnButtonClick
可能是也可能不是真正的事件处理程序。它肯定没有正确的签名。我已经回答了这个问题，考虑了所有这些因素，并提供了最直接的答案。OP还声明他们是RX的初学者，因此可能不知道如何提出如何正确实现预期行为的问题.@ibebs-这也是我在这里选择尽可能直接的答案的另一个原因。Rx在正确操作时看起来很干净。做得好。另外，
IDisposable订阅
可以更改为
SingleAssignmentDisposable
或
SerialDisposable
，然后您的
Dispose
方法。否则，请检查
Dispose
方法中的null。您知道这不会编译吗？不会有带
参数字符串[]的
重载。Return（…）
。我确实说过这是伪代码。应该不难纠正。@ibebbs-很公平。我没有发现。也许有点让人困惑，因为其他所有东西看起来都像有效的C代码，但有一行不是。据我所知，OP使用了Observable。作为实际Observable的占位符返回，这就是我复制它的原因verbatim.Rx在正确操作时看起来很干净。做得好。另外，
IDisposable订阅
可以更改为
SingleAssignmentDisposable
或
S