A utility generic worker that runs background jobs one at a time and only keeps the latest pending request. It starts a Task for a request, queues completed results to be handled on the main thread via Pump, and when multiple requests arrive while busy it drops intermediate ones and only schedules the last one to run next.
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
/// <summary>
/// Runs one background job at a time and only cares about the newest request: if more come in
/// while a job runs, the last one runs next and the ones in between are skipped. Results are
/// handed back on the main thread by <see cref="Pump"/> (call it every frame).
///
/// For things like autocomplete, where only the answer for the current keystroke matters.
/// </summary>
public class LatestOnlyWorker<T>
{
private bool _busy;
private (Func<T> Work, Action<T> Apply)? _next;
private readonly ConcurrentQueue<(T Result, Exception Error, Action<T> Apply)> _done = new();
/// <summary>
/// Called on the main thread when a job throws.
/// </summary>
public Action<Exception> OnError;
public void Request( Func<T> work, Action<T> apply )
{
if ( _busy )
{
_next = (work, apply);
return;
}
Start( work, apply );
}
private void Start( Func<T> work, Action<T> apply )
{
_busy = true;
Task.Run( work ).ContinueWith( t => _done.Enqueue( t.IsFaulted
? (default, t.Exception?.InnerException ?? t.Exception, apply)
: (t.Result, null, apply) ) );
}
public void Pump()
{
while ( _done.TryDequeue( out var done ) )
{
_busy = false;
// A newer request is waiting, so this result is already out of date
if ( _next is { } next )
{
_next = null;
Start( next.Work, next.Apply );
continue;
}
if ( done.Error is not null ) OnError?.Invoke( done.Error );
else done.Apply( done.Result );
}
}
}