Observable from event

Question

I am new to Rx and was going through some samples and came across the below:

    Observable.FromEventPattern<RoutedEventHandler, RoutedEventArgs>(
            h => new RoutedEventHandler(h),
            h => Loaded += h,
            h => Loaded -= h)
            .Select(_ => true)
            .StartWith(IsLoaded)
            .Where(l => l)
            .Take(1)
            .Subscribe(_ => Console.WriteLine("loaded");

I am trying to deconstruct this statement to figure out what it is doing but it is not 100% clear to me.

I understand how FromEventPattern is turning the Loaded event into an observable sequence. Now, Select is going to trigger when IsLoaded is true (that is what I am assuming). Is Select just getting its info from the RoutedEventArgs?

Now, I am not sure why StartsWith is there. StartsWith will prepend a sequence of values to an observable sequence. So is it just adding the value of IsLoaded to the beginning of the list? Wouldn't it already be there after Select happens?

.Where is not applying any sort of filter so .Take will just take the first value of the sequence (which in this case is not used any further). Then it Subscribes and the Console is written to only when the control is loaded.

Is this analysis mostly correct?

Also, any tips on debugging such things (meaning, what the sequence looks like during different stages of the chain)? I can get info just by attaching the debugger but I was wondering if there are any other tricks/tips that might be commonly used.

Answer 1

Most of the Observable operators work the same way the Enumerable operators of the same name. If you have experience using those, it will be useful here.

So to work through this, let's use an array of integer instead of the observable for a moment.

int[] data = {1, 2, 3, 4};

This changes the expression to

var results = data.Select(_ => true) 
                  .StartWith(IsLoaded)
                  .Where(l => l)
                  .Take(1);
foreach (var r in results)
{
    Console.WriteLine("loaded");
}

If you made an array at each stage in the expression you would get:

Select - {true, true, true, true}
StartWith - {value of IsLoaded, true, true, true, true}
Where - (if IsLoaded is true)  {true, true, true, true, true}
        (if IsLoaded is false) {true, true, true, true}
Take - {true}

With IEnumerables, doing this sort of thing doesn't make much sense because you will always get one value that is true (unless the source array is empty and IsLoaded is false).

The use of this with an IObservable is to make something that will produce one signal when the object is loaded.

• The StartWith is provides the signal if the object is already loaded at the time of subscription.
• However, if the object is not loaded, IsLoaded will be false, the Where will filter it out, and when the event fires, it will trigger a notification.
  • The Select will ignore the actual data produced by the event and simply pass a true, which will proceed through the Where filter.
• The Take is used to only trigger the notification once, regardless of it it comes from the StartWith, because the object was already loaded, or the event (via Select), when loading completes.

Answer 2

If you are new to Rx, and need some clarity regarding what each operator does, you could try out Rx Sandbox - it uses the old version of Rx, but you could probably learn from v1 before going on to v2. It allows you to visualize and try out combinators on streams, showing you the results as a marble diagram.

Here's a representation of the Zip operator.

It's easy to see that it pairs up two values from either stream.

A simple way to debug a sequence would be use the Do operator in between, like so:

    static IObservable<T> Log<T>(this IObservable<T> stream, string name)
    {
        return stream.Materialize()
                     .Do(n => Console.WriteLine("{0} - {1}",name, n))
                     .Dematerialize();
    }

Example:

        Observable.Interval(TimeSpan.FromSeconds(0.5))
                  .Log("Timer")
                  .Where(i => i % 2 == 0)
                  .Log("Where")
                  .Sample(TimeSpan.FromSeconds(2))
                  .Log("Sample")
                  .Take(1)
                  .Log("Take")
                  .Subscribe();

You can see each value propagating down the pipeline:

Timer - OnNext(0)
Where - OnNext(0)
Timer - OnNext(1)
Timer - OnNext(2)
Where - OnNext(2)
Timer - OnNext(3)
Sample - OnNext(2)
Take - OnNext(2)
Take - OnCompleted()