best way to debounce in rx? - task-parallel-library

Question

I'm using rx to observe an event.
There is only one subscriber with a lengthy operation.
The event may trigger again, when the previous operation is not finished.
how to drop this event ?
Here is what i'm searching: something like a SubscribeWithDebounceAsync method :
var observable = Observable.FromEventPattern<T>(obj, "OnSomeEvent");
observable.SubscribeWithDebounceAsync( ep => .... );

Answer 1

Your question sounds like you want to execute this operation any time the event is raised and you are not currently executing the operation. Your comments suggest you only want to execute the operation once.
The latter is simpler:
var observable = Observable.FromEventPattern<T>(...);
var disp = observable.Take(1).Subscribe(ep => ...);
For the former, I will assume that you intend to perform this long-running operation on another thread. If you don't, you will hold up the thread the Observable is raising messages on. SerialDisposable is your friend here:
<Extension()>
Public Function IgnoreWhileExecuting(Of T)(source As IObservable(Of T),
onNext As Func(Of T, Task),
onError As Action(Of Exception),
onCompleted As Action
) As IDisposable
'argument validation/error handling skipped for sample
Dim serial As New SerialDisposable
Dim syncNext As Action(Of T) = Nothing
'this function will be called for the initial and subsequent subscriptions
Dim subscribe As Func(Of IDisposable) =
Function()
Return source.Subscribe(syncNext,
onError,
onCompleted)
End Function
'this function will be "suspend" the subscription while executing
'the long-running operation, but it must return immediately to
syncNext = Sub(v)
'stop the current subscription to the source
serial.Disposable.Dispose()
'perform the long running operation and follow
'with resubscription. This will resubscribe regardless
'of if the task completes successfully or not
onNext(v).ContinueWith(Sub() serial.Disposable = subscribe())
End Sub
serial.Disposable = subscribe()
Return serial
End Function
As this will subscribe and unsubscribe, it generally assumes that you have a hot observable, like the event observable you are using in your question. You can test this out in a console app.
Sub Main()
Dim left = Observable.Interval(TimeSpan.FromMilliseconds(500))
Dim leftHot = left.Do(Sub(v) WriteTimestamped("Tick {0}", v)).Publish()
Dim f As New TaskFactory
Dim disp = leftHot _
.IgnoreWhileExecuting(Function(v)
Return f.StartNew(Sub(tparam)
WriteTimestamped("Before sleep {0}", tparam)
Thread.Sleep(2000)
WriteTimestamped("After sleep {0}", tparam)
End Sub,
v)
End Function,
Sub(ex) Console.WriteLine("Error in ignore: " & ex.ToString()),
Sub() Console.WriteLine("Completed from ignore"))
Dim con = leftHot.Connect()
Console.ReadKey()
disp.Dispose()
Console.ReadKey()
con.Dispose()
Console.ReadKey()
End Sub
Private Sub WriteTimestamped(ByVal format As String, ByVal arg As Object)
Console.WriteLine(Date.Now.ToString("HH:mm:ss.f") & " " & String.Format(format, arg))
End Sub
To see the difference between hot and cold, remove the Publish call and corresponding Connect and connection disposal and run the sample again.

Answer 2

Here's a different implementation:
public static class Extensions
{
public static IDisposable SubscribeWithDebounceAsync<T>(
this IObservable<T> source,
Action<T> longRunningTask)
{
var finished = new Subject<Unit>();
var debounced = source
.SkipUntil(finished)
.Take(1)
.Repeat()
.Subscribe(
t => Observable.Start(() =>
{
longRunningTask(t);
finished.OnNext(Unit.Default);
}));
finished.OnNext(Unit.Default);
return debounced;
}
}
The last finished.OnNext is there to get the process started, otherwise it'll stall forever on SkipUntil(finished).
EDIT: Made code more concise.