Question

Can anyone tell me what causes this seemingly odd Do behavior in the following code? I would expect the Do handler to be called once per OnNext.

using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using NUnit.Framework;

[TestFixture]
public class WhyDoesDoActSoWierd
{
    [Test]
    public void ButWhy()
    {
        var doCount = 0;
        var observable = new Subject<int>();
        var stream = observable.Do( x => doCount++ );
        var subs =
            (from x in stream
             where x % 2 == 1
             from y in stream
             where y % 2 == 0
                   && y == x + 1
             select new { x, y })
                .Subscribe( x => Console.WriteLine( "{0}, {1}", x.x, x.y ) );

        observable.OnNext( 1 );
        // doCount == 1
        observable.OnNext( 2 );
        // doCount == 3
        observable.OnNext( 3 );
        // doCount == 5
        observable.OnNext( 4 );
        // doCount == 8
        observable.OnNext( 5 );
        // doCount == 11
        observable.OnNext( 6 );
        // doCount == 15
        Assert.AreEqual( 6, doCount );
    }
}

Answer 1

The behaviour here is perfectly normal. The reason is that you don’t just have one subscription, you have many. And because of the cartesian product between the two observables in the query you have a larger number of Do than you might otherwise expect.

Let’s look at an alternative (but similar) query to yours.

    var doCountX = 0;
    var doCountY = 0;

    Action dump = () =>
        Console.WriteLine("doCountX = {0}, doCountY = {1}", doCountX, doCountY);

    var observable = new Subject<int>();

    var streamX = observable.Do(x => doCountX++);
    var streamY = observable.Do(x => doCountY++);

    var query =
        from x in streamX
        from y in streamY
        select new { x, y };

    query.Subscribe(z => Console.WriteLine("{0}, {1}", z.x, z.y));

    dump();
    for (var i = 1; i <= 6; i++)
    {
        observable.OnNext(i);
        dump();
    }

The output from this is:

doCountX = 0, doCountY = 0
doCountX = 1, doCountY = 0
1, 2
doCountX = 2, doCountY = 1
1, 3
2, 3
doCountX = 3, doCountY = 3
1, 4
2, 4
3, 4
doCountX = 4, doCountY = 6
1, 5
2, 5
3, 5
4, 5
doCountX = 5, doCountY = 10
1, 6
2, 6
3, 6
4, 6
5, 6
doCountX = 6, doCountY = 15

There’s the initial dump of doCountX = 0, doCountY = 0 which is to be expected as this call to dump() occurs before any calls to OnNext.

But when we get the first call to OnNext we don’t get a value produced by the query because the second streamY observable hasn’t yet been subscribed to.

It’s only when OnNext is called the second time do we get a value from the query which happens to be the first OnNext value paired with the second. Now this also creates a new subscriptions to streamY, waiting for the next value.

So we’ve now got the first two values from streamX waiting for the next value from the sequence. So when OnNext(3) is called we get two results.

Each time this happens you can see the number of Do calls incrementing doCountY just keep going up.

In fact, given this very plain SelectMany query the formula is:

doCountY = n * (n - 1) / 2

So with 6 values produced via OnNext you get doCountY equal to 6 * 5 / 2 or 15.

Running with 10 values gives 10 * 9 / 2 or 45 values.

So a SelectMany in fact does many more subscriptions than you might think. This is often why you would generally only use it to chain together observables that only produce a single value each to prevent the exponential explosion of subscriptions.

Does it make sense now?