Synchronous I/O within an async/await-based Windows Service

Question

Let\'s say I have a Windows Service which is doing some bit of work, then sleeping for a short amount of time, over and over forever (until the service is shut down). So in

Answer 1

A thread can only do one thing at a time. While it is working on your DoSomething it can't do anything else.

In an interview Eric Lippert described async-await in a restaurant metaphor. He suggests to use async-await only for functionality where your thread can do other things instead of waiting for a process to complete, like respond to operator input.

Alas, your thread is not waiting, it is doing hard work in DoSomething. And as long as DoSomething is not awaiting, your thread will not return from DoSomething to do the next thing.

So if your thread has something meaningful to do while procedure DoSomething is executing, it's wise to let another thread do the DoSomething, while your original thread is doing the meaningful stuff. Task.Run( () => DoSomething()) could do this for you. As long as the thread that called Task.Run doesn't await for this task, it is free to do other things.

You also want to cancel your process. DoSomething can't be cancelled. So even if cancellation is requested you'll have to wait until DoSomething is completed.

Below is your DoSomething in a form with a Start button and a Cancel button. While your thread is DoingSomething, one of the meaningful things your GUI thread may want to do is respond to pressing the cancel button:

void CancellableDoSomething(CancellationToken token)
{
    while (!token.IsCancellationRequested)
    {
        DoSomething()
    }
}

async Task DoSomethingAsync(CancellationToken token)
{
    var task = Task.Run(CancellableDoSomething(token), token);
    // if you have something meaningful to do, do it now, otherwise:
    return Task;
}

CancellationTokenSource cancellationTokenSource = null;

private async void OnButtonStartSomething_Clicked(object sender, ...)
{
    if (cancellationTokenSource != null)
        // already doing something
        return

    // else: not doing something: start doing something
    cancellationTokenSource = new CancellationtokenSource()
    var task = AwaitDoSomethingAsync(cancellationTokenSource.Token);
    // if you have something meaningful to do, do it now, otherwise:
    await task;
    cancellationTokenSource.Dispose();
    cancellationTokenSource = null;
}

private void OnButtonCancelSomething(object sender, ...)
{
    if (cancellationTokenSource == null)
        // not doing something, nothing to cancel
        return;

    // else: cancel doing something
    cancellationTokenSource.Cancel();
}