为什么 IObservables 链完全为每个订阅解析？

Question

我对如何解析 IObervables 链有疑问。我认为，如果多个观察者订阅同一个 IObservable，那么如果流发出一个新项目，整个链将只被解析一次。

相反，对于每个订阅，整个链似乎是运行。

如果我的整个程序逻辑是使用 IObservables 并将它们链接在一起的，那么在我看来，代码是运行unnesslessly 具有相同结果的相同方法。

这是故意的行为吗？为什么？
如果有，能避免吗？或者这是个坏主意？

以下代码是用 LINQPad 编写的：

{
    var subject = Observable.Range(1, 1);

    var observable1 = subject
        .Select(value =>
        {
            var nextValue = value + 2;
            Console.Write("\n Result of expensive computation: " + nextValue);
            return nextValue;
        });

    var observable2 = observable1
        .Select(value =>
        {
            var nextValue = 2 * value;
            Console.Write("\n Result of another expensive computation: " + nextValue);
            return nextValue;
        });

    observable2.Subscribe(_ => Console.Write("\n Data received on first subscription."));

    observable2.Subscribe(_ => Console.Write("\n Data received on second subscription."));
}

结果：

Result of expensive computation: 3

Result of another expensive computation: 6

Data received on first subscription.

Result of expensive computation: 3

Result of another expensive computation: 6

Data received on second subscription.

然而我期望：

Result of expensive computation: 3

Result of another expensive computation: 6

Data received on first subscription.

Data received on second subscription.

感谢您的回答。

干杯，罗布

Answer 1

第一个回答你的问题：

是的，这是预期的行为。
是的，可以避免。
回避是个不错的主意。

正如@supertopi 所说，您创建了一个冷可观察对象，其功能与您概述的一样。将它变成热可观察对象，您将拥有所需的功能。

您可以按如下方式操作：

{
    var subject = Observable.Range(1, 1);

    var observable1 = subject
        .Select(value =>
        {
            var nextValue = value + 2;
            Console.Write("\n Result of expensive computation: " + nextValue);
            return nextValue;
        });

    var observable2 = observable1
        .Select(value =>
        {
            var nextValue = 2 * value;
            Console.Write("\n Result of another expensive computation: " + nextValue);
            return nextValue;
        });

    var hotObservable = observable2.Publish().RefCount();

    hotObservable.Subscribe(_ => Console.Write("\n Data received on first subscription."));

    hotObservable.Subscribe(_ => Console.Write("\n Data received on second subscription."));

}

冷 Observables：

多次订阅触发链式操作多次代码重运行
通常来自 Observable.Create/Range/Generate/Interval/Timer
就像一个可枚举的项目，在项目之间明确定义了时间间隔。

为什么 IObservables 链完全为每个订阅解析？

Why are chains of IObservables resolved entirely for each subscription?

c#

system.reactive