Is this code ok? Is it overkill? How can it be improved?

[DrkWzrd]

Digging in and cleaning my "old" code, I found a code snippet that at first glance looks "ok" but I'm not sure if it is the correct the way to do this in .net 8-9

public class MonitoredValue<T>
{
    private readonly SemaphoreSlim _semaphore = new(1, 1);
    private readonly Func<T?, Task<bool>> _valueCondition;
    private readonly Ref<T> _monitor;
    private readonly TimeSpan _pollingDelay;

    private T? _value;

    public MonitoredValue(Func<T?, Task<bool>> valueCondition, TimeSpan pollingDelay)
    {
        _valueCondition = valueCondition;
        _pollingDelay = pollingDelay;
        _monitor = new Ref<T>(
            () => Task.FromResult(_value),
            val =>
            {
                _value = val;
                return Task.CompletedTask;
            },
            _semaphore);
    }

    public Task WaitUntilConditionIsMetAsync(CancellationToken token = default)
    {
        return WaitUntilConditionIsMetAsync(_valueCondition, token);
    }

    public async Task WaitUntilConditionIsMetAsync(Func<T?, Task<bool>> condition, CancellationToken token = default)
    {
        try
        {
            while (!token.IsCancellationRequested
                && !await condition(await _monitor.GetValue(token)))
            {
                await Task.Delay(_pollingDelay, token);
            }

        }
        catch (OperationCanceledException ex) when (ex.CancellationToken == token)
        {
        }
    }

    public Task<T?> GetValue(CancellationToken token = default)
    {
        return _monitor.GetValue(token);
    }

    public Task SetValue(T? sVal, CancellationToken token = default)
    {
        return _monitor.SetValue(sVal, token);
    }

    private sealed class Ref<TRef> where TRef : T
    {
        private readonly Func<Task<TRef?>> _getter;
        private readonly Func<TRef?, Task> _setter;
        private readonly SemaphoreSlim _semaphore;

        public Ref(Func<Task<TRef?>> getter, Func<TRef?, Task> setter, SemaphoreSlim semaphore)
        {
            _getter = getter;
            _setter = setter;
            _semaphore = semaphore;
        }

        public async Task<TRef?> GetValue(CancellationToken token = default)
        {
            await _semaphore.WaitAsync(token);
            try
            {
                var rVal = await _getter();
                return rVal;
            }
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task SetValue(TRef? sVal, CancellationToken token = default)
        {
            await _semaphore.WaitAsync(token);
            try
            {
                await _setter(sVal);
            }
            finally
            {
                _semaphore?.Release();
            }
        }
    }
}

The goal of this code is to wait until a value or reference change achieves a condition or a cancellation is requested.

Is Ref private class needed? How can be improved, looking to new .net elements included?

[Joe4evr]

This is not a forum for code review.

[Clockwork-Muse]

Generally speaking, you want to avoid polling when possible, in preference for sending events of some sort from triggering code (like having whatever sets the value also set the completed task or flipping a ManualResetEvent).

If you persist in going down this path, C++ has something known as condition variables that perform this function, so I wouldn't be too surprised if you could find a NuGet package for this.