Question

AsycSubject<Unit>() sub;
// stuff
if(!sub.HasFired())
  // Do stuff

Current best attempt is:

public static bool HasFired<T>(this AsyncSubject<T> sub)
{
    AsyncSubject<bool> ret = new AsyncSubject<bool>();
    sub.Timeout(TimeSpan.FromMilliseconds(20))
        .Subscribe(_ =>
            {
                ret.OnNext(true);
                ret.OnCompleted();
            },
            ex => 
            {
                ret.OnNext(false);
                ret.OnCompleted();
            });
    return ret.First();
}

But it feels very ugly and long. I suspect I’m missing something simple. Any suggestions?

Answer 1

It’s easier to wrap around the existing AsyncSubject and add the required state.

public class AsyncSubjectEx<T> : ISubject<T>, IDisposable
{
    AsyncSubject<T> Subject = new AsyncSubject<T>();

    public bool HasValue { get; protected set; }

    public object Gate = new object();

    public void OnCompleted()
    {
        Subject.OnCompleted();
    }

    public void OnError(Exception error)
    {
        Subject.OnError(error);
    }

    public void OnNext(T value)
    {
        lock (Gate)
        {
            Subject.OnNext(value);
            HasValue = true;
        }
    }

    public IDisposable Subscribe(IObserver<T> observer)
    {
        lock (Gate)
            return Subject.Subscribe(observer);
    }

    public void Dispose()
    {
        Subject.Dispose();
    }
}

Ironically, the original AsyncSubject upon reflection shows that there is a hasValue field, but it doesn’t happen to be exposed. Consider reporting this to the Rx team – might be useful sometime.