Prepend Task to IObservable (symmetry of Finally)

Question

I want to send a start pulse to my server when the first client connects, and a finish pulse when the last one disconnects.

public class MyAdapter : IObservable<MyType> {

    IObservable<MyType> MyObservable = BuildMyObservable()
        .Initially(Start) // <- this method doesn't exist
        .Finally(Stop).Publish().RefCount().Subscribe(observer);

    public IDisposable Subscribe(IObserver<MyType> observer);
        return MyObservable.Subscribe(observer)
    }

    async Task Start() { /* start UDP stream */ }
    async Task Stop() { /* stop UDP stream */ }
    IObservable<MyType> BuildMyObservable() { /* wire up stuff */ }

}

In the above method, am I looking for a function Initially that doesn't exist, or am I just overlooking it?

Answer 1

You could simply treat the Task like any other sequence, and just chain it into the query

Start().ToObservable()
  .SelectMany(_=>MyObservable)
  .Finally(Stop)

As a separate note, I would encourage you to avoid crafting API's that have methods that take the format IDisposable Subscribe(IObserver<MyType> observer). This takes away the power of Rx from your consumers. Instead, just expose the IObservable<T>, as it has the Subscribe method already. Now your consumer can chain your sequence, compose it, choose the correct concurrency/threading model (with ObserveOn/SubscribeOn), and apply their Error handling requirements.

Also as a last note, it is a bit strange to publish-refcount a sequence that is the result of a method call. It is even more strange to publish-refcount when your method only allows the consumer to provide one consumer. Assuming you change your method signature to the recommended/standard approach, then I would also suggest that you either remove the Publish().Refcount() code as it would highly unlikely for the consumer to cached the result and reuse it, v.s. recalling the method. Or you can keep the method (even better change it to a property) and then you internally cache the published sequence.

public class MyServiceThing
{
    private readonly IObservable<MyType> _myObservable;

    public MyServiceThing()
    {
        _myObservable = Start().ToObservable()
            .SelectMany(_=>/*The thing that defines your observable sequence...*/)
            .Finally(Stop)
            .Publish().RefCount();
    }

    public IObservable<MyType> MyObservable()
    {
        return _myObservable;
    }
    //OR
    //public IObservable<MyType> MyObservable() { get { return _myObservable; } }

    private async Task Start() {}
    private async Task Stop() {}
}

Answer 2

I guess you are looking for a .Net equivalent of doOnSubscribe from RxJava. It does not exist out of the box.

What you can do, is wrap your MyObservable in Observable.Defer function, and call your server inside the Defer. You can play with the below code to see what I mean:

class Program
{
    static void Main(string[] args)
    {
        var source = Observable.Interval(TimeSpan.FromSeconds(1));

        var published = Observable.Defer(() =>
        {
            Console.WriteLine("Start"); // Here, you post "Start" to server
            return source;
        })
        .Finally(() => Console.WriteLine("End")) // Here, you post "End"
        .Publish()
        .RefCount();

        Console.ReadLine();
        var disposable = published.Subscribe(x => Console.WriteLine("First " + x));
        Console.ReadLine();
        var disposable2 = published.Subscribe(x => Console.WriteLine("Second " + x));
        Console.ReadLine();
        disposable.Dispose();
        Console.ReadLine();
        disposable2.Dispose();
        Console.ReadLine();
        published.Subscribe(x => Console.WriteLine("Third " + x));
        Console.ReadLine();
    }
}

For more explanation about deferring, see this excellent blogpost.

Answer 3

Using pmbanka's correct answer, I added an Observable extension for this.

public static IObservable<T> Initially<T>(this IObservable<T> resultingObservable, Func<Task> initialAction) {
    return Observable.Defer(async () =>
    {
        await initialAction();
        return resultingObservable;
    });
}

public static IObservable<T> Initially<T>(this IObservable<T> resultingObservable, Action initialAction) {
    return Observable.Defer(() =>
    {
        Action();
        return resultingObservable;
    });
}

It's as-yet untested, and may not be optimal regarding async/task lambdas.

I guess the following does the same:

public static IObservable<T> Initially<T>(this IObservable<T> resultingObservable, Func<Task> initialAction) {
    return Observable.Create(async (IObserver<T> observer) =>
    {
        await initialAction();
        return resultingObservable.Subscribe(observer);
    });
}