Reactive Programming in synchronous environment: performance vs dependency management - performance

Question

I understand that Reactive Programming shine in asynchronous environment (web request, or heavy IO/multi-threading/background task. However, in synchronous world, I found that Reactive Programming still give a great benefit of freeing dependency management burden from the programmer. I am writing a desktop app using C# that act like a spreadsheet: lots inputs, calculation on these inputs, and outputs. I am using RX.net and enjoying the benefit free dependency management it gave me: when an input change, i do not need to know what calculation need to be redo, and what ui need to be updated. However, as there are more synchronous/sequential calculation involve, the performance hit from using observable become greater. Consider these 2 ways of coding:
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");
}
assuming my_to_upper() is a slow process:
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();
}
for async_world(), my_to_upper() is executed twice comparing to sync_world(). It would be nice that when data arrive ( on each onNext call ) A_ob perform calculation and "cache" the result of my_to_upper() and pass it on to AA_ob and AAA_ob
So my question is: is this a trade off we have to make: let the computer manage dependency automatically for us with inefficient performance, or manually manage dependency to gain better performance.

Answer 1

It is possible to 'cache' the result with the various Publish over-loads:
Here's a Published form of async with 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");
}
And here's a Published form without 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");
}
The publish without RefCount form is probably preferred if you're a fan of functional, reactive-y things: It effectively caches an observable's result values, and makes them available inside the limited lambda scope where you have to produce a selector to decide what to do with it. You could if necessary nest Publish lambdas to access multiple "cached" observable values.
Publish + RefCount, in contrast promotes statement-y, iterative-looking pipelines. Generally less recommended.
You can read more about Publish, RefCount and hot vs cold observables here.