ThreadPool.RegisterWaitForSingleObject пропускает объекты RegisteredWaitHandle (и память) с течением времени

Я создаю метод расширения для WaitHandles (особенно ManualResetEventSlim), чтобы их можно было использовать в асинхронном коде. Использование выглядит следующим образом:

public class WaitHandleExampleClass : IDisposable
{
    private readonly ManualResetEventSlim _mre;
    public WaitHandleExampleClass()
    {
        _mre = new ManualResetEventSlim(false);
    }

    public async Task WaitForHandle()
    {
        using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
        {
            var cancelled = await _mre.WaitHandle.WaitForSignalOrCancelAsync(cts.Token)
.ConfigureAwait(false);
            
            if (cancelled)
            {
                DoCancelAction();
                return;
            }

            Proceed();
            // later, _mre.Reset() is called
        }
    }

    public void TriggerWaitHandleFromOtherThread()
    {
        _mre.Set();
    }

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

Мой метод расширения WaitForSignalOrCancelAsync() выглядит следующим образом:

public static Task<bool> WaitForSignalOrCancelAsync(this WaitHandle waitHandle, CancellationToken ct)
{
    if (waitHandle == null)
        throw new ArgumentNullException(nameof(waitHandle));
    
    var tcs = new TaskCompletionSource<bool>();
    var task = tcs.Task;
    var container = new CleanupContainer();
    // dont pass ct to ContinueWith - otherwise rwh is not unregistered (even with TaskContinuationOptions.None)
    task.ContinueWith(TaskContinueWith, container, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

    container.Ctr = ct.Register(SetCancel, tcs, false);
    container.Rwh = ThreadPool.RegisterWaitForSingleObject(waitHandle, RwhCallback, tcs, -1, true);
    
    return task;
}
private static void SetCancel(object state) => ((TaskCompletionSource<bool>)state).TrySetResult(true);

private static void RwhCallback(object state, bool o) => ((TaskCompletionSource<bool>)state).TrySetResult(false);

private static void TaskContinueWith(Task t, object state)
{
    try
    {
        ((CleanupContainer)state).Cleanup();            
    }
    catch (Exception e)
    {
        DebugAssert.ShouldNotBeCalled();
    }
}

private class CleanupContainer
{
    public RegisteredWaitHandle Rwh { get; set; }
    public CancellationTokenRegistration Ctr { get; set; }

    public void Cleanup()
    {
        // so this just waits until the condition is true (returns true) or timeout is reached (returns false)
        var conditionOk = SpinWait.WaitFor(() => Rwh != null && Ctr != default, timeoutMs: 200);
        DebugAssert.MustBeTrue(conditionOk); // always true in debug -> Rwh and Ctr are set

        var rwhUnregisterOkay = Rwh?.Unregister(null);
        DebugAssert.MustBeTrue(rwhUnregisterOkay == true); // also always true
        Ctr.Dispose();

        Rwh = null;
        Ctr = default;
    }
}

После развертывания и запуска этого кода в качестве службы Windows в течение нескольких часов я вижу, что использование памяти увеличивается. Также увеличивается загрузка ЦП, но я не уверен, связано ли это с этим. Итак, я прикрепил dotmemory. Со временем у меня появляется все больше и больше объектов:

• TaskCompletionSource<bool> -> 241 890
• ОтменаCallbackInfo-> 241,984
• ThreadPoolWaitOrTimerCallback -> 241 890

Скриншот Dotmemory

Не поможет, если я заставлю GC с помощью dotmemory

Я предполагаю, что это связано с описанным выше методом расширения, но я не понимаю, почему. За основу я взял этот код MSDN («От дескрипторов ожидания до TAP»): https://learn.microsoft.com/en-us/dotnet/standard/asynchronous-programming-patterns/interop-with-other-asynchronous -шаблоны-и-типы#см.также

Я также написал свой первый модульный тест с интеграцией dotmemory, не уверен, что он правильный и полезный. Но при этом я знаю, что Rwh.Unregister() делает другое, так как количество объектов отличается, если оно закомментировано в методе Cleanup. Он красный, потому что зарегистрированныйWaitHandles.ObjectsCount == 1, а не 0.

[TestMethod]
[DotMemoryUnit(FailIfRunWithoutSupport = false)]
public async Task WaitForSignalOrCancelAsync_ResourcesAreReleased()
{
using (var waitHandle = new ManualResetEventSlim(false))
{
var cancellationTokenSource = new CancellationTokenSource();
var task = waitHandle.WaitHandle.WaitForSignalOrCancelAsync(cancellationTokenSource.Token);

        cancellationTokenSource.Cancel();
        await task;
        
        for (var i = 0; i < 10; i++)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
        
        Thread.Sleep(200);
    
        for (var i = 0; i < 10; i++)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
        
        dotMemory.Check(memory =>
        {
            var registeredWaitHandles = memory.GetObjects(where => where.Type.Is<RegisteredWaitHandle>());
            // if i comment out the Rwh.Unregister() in CleanupContainer.Cleanup() i get 2 as count here
            // with Rwh.Unregister(), i get 1 here
            registeredWaitHandles.ObjectsCount.MustBeEqualTo(0, "rwh > 1");
    
            var cancellationTokenRegistrations = memory.GetObjects(where => where.Type.Is<CancellationTokenRegistration>());
            cancellationTokenRegistrations.ObjectsCount.MustBeEqualTo(0, "ctr > 0");
        });
    }

}

Редактировать: Я попробовал решение Ивана (ссылка на stackoverflow), но столкнулся с той же проблемой. Мой модульный тест все еще красный с двумя оставшимися ссылками. Я кратко проверил это на сервере, через 20 минут вижу увеличение новых объектов 3-х типов (TaskCompletionSource,...)

Я быстро попробовал AsyncEx, но при этом мой модульный тест тоже стал красным

Код, который я пробовал:

public static async Task<bool> WaitForSignalOrCancelAsync(this WaitHandle waitHandle, CancellationToken cancellationToken, int timeoutMilliseconds = Timeout.Infinite)
{
    try
    {
        await waitHandle.WaitOneAsync(cancellationToken, timeoutMilliseconds).ConfigureAwait(false);
        return false; // no cancel
    }
    catch (OperationCanceledException)
    {
        return true; // cancel
    }
}

private static Task WaitOneAsync(this WaitHandle waitHandle, CancellationToken cancellationToken, int timeoutMilliseconds = Timeout.Infinite)
{
    if (waitHandle == null)
        throw new ArgumentNullException(nameof(waitHandle));

    TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
    CancellationTokenRegistration ctr = cancellationToken.Register(() => tcs.TrySetCanceled());
    TimeSpan timeout = timeoutMilliseconds > Timeout.Infinite ? TimeSpan.FromMilliseconds(timeoutMilliseconds) : Timeout.InfiniteTimeSpan;

    RegisteredWaitHandle rwh = ThreadPool.RegisterWaitForSingleObject(waitHandle,
        (_, timedOut) =>
        {
            if (timedOut)
            {
                tcs.TrySetCanceled();
            }
            else
            {
                tcs.TrySetResult(true);
            }
        },
        null, timeout, true);

    Task<bool> task = tcs.Task;

    _ = task.ContinueWith(_ =>
    {
        var ok = rwh.Unregister(null);
        var ok2 = rwh.Unregister(waitHandle);
        ctr.Dispose();
    }, CancellationToken.None);

    return task;
}