Concurrent non-blocking update of cached list of on-line users

class AsyncDictionary<TKey, TValue>
    where TValue : class
{
    ConcurrentDictionary<TKey, TValue> Values { get; } =
        new ConcurrentDictionary<TKey, TValue>();

    public delegate bool TryUpdate(ref TValue value);
    
    /// <summary>
    /// It makes multiple attempts to execute if item under the question is marked for deletion.
    /// </summary>
    /// <param name="key">Well, the key.</param>
    /// <param name="add">Value factory for add opeartion.</param>
    /// <param name="tryUpdate">It will try to update, but might reject to do so.</param>
    /// <returns>Reports actual operation executed and the value assigned.</returns>
    public async Task<Result> AddOrUpdateAsync(TKey key, Func<TValue> add, TryUpdate tryUpdate)
    {
        while (true)
        {
            var result = Result.Cancelled;
            Values.AddOrUpdate(key,
                (k) =>
                {
                    result = new Result(ValueAction.Added, add());
                    return result.Value;
                },
                (k, v) =>
                {
                    if (v == null)
                        result = Result.Delayed;
                    else                        
                        result = tryUpdate(ref v) ?
                            new Result(ValueAction.Updated, v) :
                            Result.Cancelled;                        

                    return v;
                });

            if (result.Action == ValueAction.Delayed)
                await Task.Delay(10);
            else
                return result;
        }
    }

    /// <summary>
    /// Concurrent remove first marks the entry for deletion by assigning null 
    /// to the value. 
    /// </summary>
    /// <param name="key">Well, the key.</param>
    /// <param name="guard">Checks if we really want to kill it.</param>
    /// <returns></returns>
    public Result Remove(TKey key, Predicate<TValue> guard)
    {
        TValue value;
        if (!Values.TryGetValue(key, out value))
            return Result.Cancelled;

        if (value == null)
            return Result.Cancelled;

        if (!guard(value))
            return Result.Cancelled;

        if (!Values.TryUpdate(key, null, value))
            return Result.Cancelled;

        TValue nullValue;
        Values.TryRemove(key, out nullValue);
        if (nullValue != null)
            throw new NotImplementedException();

        return new Result(ValueAction.Removed, value);
    }

    /// <summary>
    /// Removes everything matching the predicate.
    /// </summary>
    /// <param name="predicate">To be or not to be.</param>
    /// <returns>The corpses.</returns>
    public IEnumerable<Result> Remove(Predicate<TValue> predicate) =>
        from kvp in Values
        where predicate(kvp.Value)
        select Remove(kvp.Key, predicate) into r
        where r.Action == ValueAction.Removed
        select r;        

    public struct Result
    {
        public static 

interface IClock
{
    DateTimeOffset GetTime();
}

interface ISessionMonitor : IDisposable
{
    Task StartAsync(Session session);
    Task EndAsync(Session session);
}

interface IPingMonitor : IDisposable
{
    Task PingAsync(AgentId agentId);
}

struct AgentId
{
    public static implicit operator AgentId(int value) => new AgentId { Value = value };
    public static implicit operator int(AgentId agentId) => agentId.Value;
    int Value { get; set; }
    public override string ToString() => $"Agent #{Value}";
}

class Session : ValueObject<Session>
{
    private static readonly TimeSpan Ttl = TimeSpan.FromMinutes(10);

    public static Session Start(AgentId agentId, DateTimeOffset at) =>
        new Session(agentId, at, at);

    public Session(AgentId agentId, DateTimeOffset started, DateTimeOffset lastActivity)
    {
        AgentId = agentId;
        Started = started;
        LastActivity = lastActivity;
    }

    public AgentId AgentId { get; }
    public DateTimeOffset Started { get; }
    public DateTimeOffset LastActivity { get; }
    public bool IsExpired(DateTimeOffset at) => LastActivity + Ttl < at;

    public bool TryExtend(DateTimeOffset till, out Session extended)
    {
        extended = this;
        if (IsExpired(till))
            return false;

        extended = new Session(AgentId, Started, till);
        return true;
    }

    protected override IEnumerable<object> EqualityCheckAttributes =>
        new object[] { AgentId, Started };
}

class PingMonitor : IPingMonitor
{
    private static readonly TimeSpan Interval = TimeSpan.FromMinutes(1);
    AsyncDictionary<AgentId, Session> Sessions { get; } =
        new AsyncDictionary<AgentId, Session>();

    public PingMonitor(IClock clock, ISessionMonitor monitor)
    {
        Clock = clock;
        Monitor = monitor;
        CancellationTokenSource = new CancellationTokenSource();
        Task.Run(RunAsync);
    }

    public void Dispose()
    {
        CancellationTokenSource.Cancel();
        Monitor.Dispose();
    }

    IClock Clock { get; }
    ISessionMonitor Monitor { get; }
    CancellationTokenSource CancellationTokenSource { get; }

    public Task PingAsync(AgentId agentId) =>
        StartOrExtendAsync(agentId);

    async Task StartOrExtendAsync(AgentId agentId)
    {
        var result = await Sessions.AddOrUpdateAsync(
            agentId,
            () => Session.Start(agentId, Clock.GetTime()),
            (ref Session s) => s.TryExtend(Clock.GetTime(), out s));

        switch (result.Action)
        {
            case ValueAction.Added:
                await Monitor.StartAsync(result.Value);
                return;

            case ValueAction.Updated:
                return;

            case ValueAction.Cancelled:
                await EndAsync(agentId);
                await StartOrExtendAsync(agentId);
                return;

            default:
                throw new NotImplementedException();
        }
    }

    async Task EndAsync(AgentId agentId)
    {
        var result = Sessions.Remove(agentId, s => s.IsExpired(Clock.GetTime()));
        switch (result.Action)
        {
            case ValueAction.Removed:
                await Monitor.EndAsync(result.Value);
                return;

            case ValueAction.Cancelled:
                return;

            default:
                throw new NotImplementedException();
        }
    }

    async Task RunAsync()
    {
        while (!CancellationTokenSource.Token.IsCancellationRequested)
        {
            await Task.Delay(Interval, CancellationTokenSource.Token);
            await Task.WhenAll(from r in Sessions.Remove(s => s.IsExpired(Clock.GetTime()))
                               select Monitor.EndAsync(r.Value));
        }
    }
}