Estoy investigando el uso de Observable.Generate para crear una secuencia de resultados muestreados a intervalos utilizando los ejemplos del sitio web msdn como punto de partida.

El siguiente código SIN un selector de TimeSpan no presenta una pérdida de memoria:

IObservable<string> obs = Observable.Generate(initialState: 1,
                                              condition: x => x < 1000,
                                              iterate: x => x + 1,
                                              resultSelector: x => x.ToString());
obs.Subscribe(x => Console.WriteLine(x));

Sin embargo, el siguiente código CON un selector TimeSpan exhibe una pérdida de memoria:

TimeSpan timeSpan = TimeSpan.FromSeconds(1);
IObservable<string> obs = Observable.Generate(initialState: 1,
                                              condition: x => x < 1000,
                                              iterate: x => x + 1,
                                              resultSelector: x => x.ToString(),
                                              timeSelector: x => timeSpan);
obs.Subscribe(x => Console.WriteLine(x));

Por ejemplo, esta aplicación de juguete mostrará rápidamente la pérdida de memoria utilizando el Memory Profiler que se incluye con la comunidad VS 2015:

using System;
using System.Reactive.Linq;

namespace Sample
{
    public class Program
    {
        static void Main()
        {
            IObservable<string> obs = Observable.Generate(1, x => x < 1000*1000, x => x + 1, x => x.ToString(), x => TimeSpan.FromMilliseconds(500));
            obs.Subscribe(x => { /*Do nothing but simply run the observable*/ });
            Console.ReadLine();
        }
    }
}

La pérdida de memoria es una colección creciente de:

System.Reactive.Disposables StableCompositeDisposable.Binary
System.Reactive.Disposables SingleAssignmentDisposable

¿Estoy usando esta API incorrectamente? ¿Debería esperar que la memoria crezca o es un error con Reactive?