Question

据我所知，Reactive Programming在异步环境（Web请求，或重IO /多线程/后台任务）中大放异彩。但是，在同步世界中，我发现Reactive Programming仍然可以从释放依赖管理负担中获得很大好处。程序员。我正在使用C＃编写一个桌面应用程序，其作用类似于电子表格：大量输入，计算这些输入和输出。我正在使用RX.net并享受它带给我的免费依赖管理：当输入改变时，我不需要知道需要重做什么计算，以及需要更新什么ui。但是，由于涉及更多同步/顺序计算，使用可观察性的性能变得更大。考虑这两种编码方式：

  private static void async_world()
  {
     Subject<string> a_ob = new Subject<string>();
     IObservable<string> A_ob = a_ob.Select(str =>
     {
        return my_to_upper(str);
     });
     IObservable<string> AA_ob = A_ob.Select(str => $"{str}{str}");
     IObservable<string> AAA_ob = A_ob.Select(str => $"{str}{str}{str}");
     IObservable<string> AA_AAA_ob = Observable.CombineLatest(AA_ob, AAA_ob,
     (AA, AAA) =>
     {
        return $"{AA}_{AAA}";
     });

     AA_AAA_ob.Subscribe(str => Console.Out.WriteLine(str));
     a_ob.OnNext("a");
  }

  private static void sync_world()
  {
     Subject<string> a_ob = new Subject<string>();

     IObservable<string> result_ob = a_ob.Select(str =>
     {
        var upper = my_to_upper(str);

        var AA = $"{upper}{upper}";
        var AAA = $"{upper}{upper}{upper}";

        return $"{AA}_{AAA}";
     });

     result_ob.Subscribe(str => Console.Out.WriteLine(str));
     a_ob.OnNext("a");
  }

假设my_to_upper（）是一个缓慢的过程：

  private static string my_to_upper(string str)
  {
     Console.Out.WriteLine($"{str}.ToUpper...");
     for (int i = 0; i < 1000000; i++)
     {
        for (int j = 0; j < 2000; j++)
        {

        }
     }
     Console.Out.WriteLine($"{str}.ToUpper...done");
     return str.ToUpper();
  }

对于async_world（），my_to_upper（）与sync_world（）相比执行两次。当数据到达时（在每次onNext调用时），A_ob执行计算并“缓存”my_to_upper（）的结果并将其传递给AA_ob和AAA_ob

所以我的问题是：这是我们必须做出的权衡：让计算机自动为我们管理依赖性，效率低下，或者手动管理依赖关系以获得更好的性能。

Answer 1

可以使用各种Publish过载来“缓存”结果：

以下是Publish + RefCount的发布形式：

private static void async_world_publish_refcount()
{
    Subject<string> a_ob = new Subject<string>();
    IObservable<string> A_ob = a_ob
        .Select(str => my_to_upper(str)) //same function call as async_world_original, just removed braces.
        .Publish()
        .RefCount();

    IObservable<string> AA_ob = A_ob.Select(str => $"{str}{str}");
    IObservable<string> AAA_ob = A_ob.Select(str => $"{str}{str}{str}");
    IObservable<string> AA_AAA_ob = Observable.CombineLatest(AA_ob, AAA_ob,
    (AA, AAA) =>
    {
        return $"{AA}_{AAA}";
    });

    AA_AAA_ob.Subscribe(str => Console.Out.WriteLine(str));
    a_ob.OnNext("a");
}

这是一个没有RefCount的已发布表单：

private static void async_world_publish_only()
{
    Subject<string> a_ob = new Subject<string>();
    IObservable<string> AA_AAA_ob = a_ob
        .Select(str => my_to_upper(str)) //same function call as async_world_original, just removed braces.
        .Publish(A_ob => 
            Observable.CombineLatest(
                A_ob.Select(str => $"{str}{str}"),
                A_ob.Select(str => $"{str}{str}{str}"),
                (AA, AAA) => $"{AA}_{AAA}"
            )
        );

    AA_AAA_ob.Subscribe(str => Console.Out.WriteLine(str));
    a_ob.OnNext("a");
}

如果你是功能性的，反应性的东西的粉丝，那么没有RefCount形式的发布可能是首选的：它有效地缓存了一个可观察的结果值，并使它们在有限的lambda范围内可用，你需要生成一个选择器决定如何处理它。如果需要，您可以嵌套Publish lambdas来访问多个“缓存”可观察值。

相反，

Publish + RefCount会促进语句y，迭代查找管道。一般不太推荐。

您可以详细了解Publish，RefCount以及热门与冷可观测量here。

同步环境中的反应式编程：性能与依赖性管理

1 个答案: