TransformOnObservable vs AutoRefreshOnObservable + Transform?

[paagamelo2]

Ciao guys

Just wondering if the two operators are any different, or if they effectively behave the same. In case they're equivalent, is there any rule of thumb to follow when deciding which of the two to use?

Thanks
Lorenzo

[dwcullop]

They seem similar but are different. Which one you want depends on the specifics of the situation.

Use TransformOnObservable when the sub-observable fires the value that should be the result of the transformation. Each value from the sub-observable will trigger an Add/Update event in the downstream for the corresponding key.

Use AutoRefreshOnObservable + Transform when the refresh observable and the Transform don't have anything to do which each other. AutoRefreshOnObservable will trigger a Refresh event in the downstream, which will cause the Transform to be applied, but the Transform won't have any access to the value that the AutoRefreshOnObservable fired because it was translated into a refresh event.

[paagamelo2]

Thanks @dwcullop, that makes sense. However, I think there are particular cases in which both could used.

I've set up a minimal example which is somewhat similar to a use case we have in production. In this particular case, the current value of the observable is also exposed as a property, so we're able to use AutoRefreshOnObservable and grab the current value in the following Transform.

class Example
{
    private record Person(string Name, DateTimeOffset DateOfBirth);

    // Calculates the age of a person and exposes it as an observable.
    private class AgeService
    {
        // BehaviourSubject lets you access the current value of the observable
        // This "pattern" is the same you'd have with an object that implements INotifyPropertyChanged
        public BehaviorSubject<int?> AgeChanged { get; } = new(null);

        public AgeService(Person person)
        {
            Observable
                .Interval(TimeSpan.FromDays(1))
                .Select(_ => ComputeAge(person))
                .DistinctUntilChanged()
                .Subscribe(newAge => AgeChanged.OnNext(newAge));
        }

        private static int ComputeAge(Person person)
        {
            return DateTimeOffset.Now.Year - person.DateOfBirth.Year;
        }
    }

    private void TransformOnObservableVsAutoRefresh(IObservableCache<Person, string> cache)
    {
        // Option 1
        cache
            .Connect()
            .Transform(person =>
                (Person: person, AgeService: new AgeService(person)))
            .TransformOnObservable(tuple => tuple
                .AgeService
                .AgeChanged
                .Select(age => (tuple.Person, Age: age)))
            .Subscribe( /*TODO*/ );

        // Option 2
        cache
            .Connect()
            .Transform(person =>
                (Person: person, AgeService: new AgeService(person)))
            .AutoRefreshOnObservable(tuple => tuple.AgeService.AgeChanged)
            .Transform(tuple =>
                    (tuple.Person, tuple.AgeService.AgeChanged.Value),
                transformOnRefresh: true)
            .Subscribe( /*TODO*/ );
    }
}

As far as I can tell, the two options behave the same. If that's the case, is there any reason to prefer one over the other?

Thanks again
Lorenzo

[JakenVeina]

I this particular case, since you're transforming downstream anyway, into immutable tuples, there's effectively no difference. If you really dig in, Option 1 is probably a hair more performant, just because it's one operator instead of 2, so there's less changeset churn. At least potentially, it also heavily depends on the internal implementation of the operators, and even with the differences, we're likely talking micro-optimization levels of performance.