Task.Delay（Timeout.Infinite）是一个非阻塞调用，可以用来无限期地无阻塞地进行睡眠吗？

Question

I am using Cosmos DB Change Feed library to process documents from Change Feed.

var docObserverFactory = DocumentFeedObserverFactory.Create(myCollectionInfo);
await host.RegisterObserverFactoryAsync(docObserverFactory);
Console.WriteLine("Awaiting indefinitely...press Cancel to exit");

// I set the CancellationToken to true on Console.CancelKeyPress Event
await Task.Delay(Timeout.Infinite, cancellationToken);
await host.UnregisterObserversAsync();

In the above code, after registering the observer factory, I need to hold this thread for an indeterminate time. Hence I use Task.Delay with infinite timeout value.

Questions:

1. I wanted to know if it is right to use Task.Delay() in this way.
2. I am concerned Task.Delay() will block a thread internally in case of infinite timeout to monitor the cancellation token.

Basically, I want a non-blocking sleep call that waits indefinitely without blocking.

Answer 1

It feels a bit strange to use Task.Delay for that (especially because the cancel, which is expected, causes a CancellationException ) . I prefer to use SemaphoreSlim for Tasks like this.

    private readonly SemaphoreSlim blockUntilFinishedOrCancel = new SemaphoreSlim(0);

    //Wait
    await this.blockUntilFinishedOrCancel.WaitAsync():

    //No More Waiting
    this.blockUntilFinishedOrCancel.Release(1);

Answer 2

This is alternative not exactly answer to the question.

You need to block the access to host.UnregisterObserversAsync() until some event occur right ?

You can use Monitor to simulate something like producer / consumer scenario.

Your approach should also do the job, but it looks a bit hacky ... on the other side the producer / consumer may be an overkill for something simple. Play with the code and see what feels right for you.

Answer 3

Thanks for all your answers and comments, I realize understood it wrong by seeing the below code on Change Feed usage on the internet. Particularly misunderstood "Console.ReadLine" as blocking the thread and I need to do the same. But there is no need to block this thread to unregister it. It can be done by any other thread.

using (DocumentClient destClient = new DocumentClient(destCollInfo.Uri, destCollInfo.MasterKey))
{
    DocumentFeedObserverFactory docObserverFactory = new DocumentFeedObserverFactory(destClient, destCollInfo);

    ChangeFeedEventHost host = new ChangeFeedEventHost(hostName, documentCollectionLocation, leaseCollectionLocation, feedOptions, feedHostOptions);
    await host.RegisterObserverFactoryAsync(docObserverFactory);

    // This is where I thought I need to block this thread indeterminately.
    Console.WriteLine("Running... Press enter to stop.");
    Console.ReadLine();

    await host.UnregisterObserversAsync();
}

As an alternative, I can make the ChangeFeedEventHost part of my class and expose a method to unregister it. On the CancelKeyPress event, I can call that unregsiter method. This way I need not sleep/block a thread indeterminately.