Reactive Extensions ToEnumerable how to dispose observable state if not iterating everything

Question

If I use the ToEnumerable extension on an IObservable, there is a chance the user will not iterate all of the elements. In that case how can the IDisposable declared in Observable.Create be properly disposed?

For the sake of argument let's say that it is not an option to directly return the IObservable to the user (in which case the user could implement cancellation themselves).

 private IObservable<Object> MakeObservable()
 {
   return Observable.Create(async (observer, cancelToken) =>
   {
     using(SomeDisposable somedisposable = new SomeDisposable())
     {
        while(true)
        {
          Object result = somedisposable.GetNextObject();
          if(result == null)
          {
            break;
          }
          observer.OnNext(result);
        }       
     }
   }
 }

 public IEnumerable<Object> GetObjects()
 {
   return MakeObservable().ToEnumerable();
 }

 public void Test()
 {
   IEnumerable<Object> e = GetObjects();
   int i = 0;
   foreach(Object o in e)
   {
     if(i++ == 10)
        break;
   }
   //somedisposable is not disposed here!!!
 }

Answer 1

The issue is that your definition of Create doesn't return so it can't be stopped. If you change your source observable to something based on a timer then it works fine. Try this code:

public IEnumerable<long> GetObjects()
{
    return Observable
        .Interval(TimeSpan.FromSeconds(1.0))
        .Finally(() => Console.WriteLine("Done."))
        .ToEnumerable();
}

public void Test()
{
    foreach (long i in GetObjects())
    {
        Console.WriteLine(i);
        if (i == 10)
        {
            break;
        }
    }
}

When you run that you get this output:

0
1
2
3
4
5
6
7
8
9
10
Done.

It's clearly calling OnCompleted on the source observable.