C＃任务等待和超时

Question

I am trying to use the following technique to be able to have a worker task executing some operations, with a 10 sec timeout and without blocking the application.

internal void ReadAll()
{
    var data = new byte[1];

    Task.Factory.StartNew(() =>
    {
        var ct = new CancellationTokenSource();
        var ReadAllTask = Task.Factory.StartNew(() =>
        {
            // Read all information
            // [omit communication exchange via COM port]

            ct.Cancel();
        }, ct.Token);

        // First thread waiting 10s for the worker to finish
        ReadAllTask.Wait(10000, ct.Token);

        if (ReadAllTask.Status == TaskStatus.RanToCompletion)
        {
            ReadAllComplete?.Invoke(true);
        }
        else
        {
            ct.Cancel();
            ReadAllComplete?.Invoke(false);
        }
    });
}

This method is called by pressing a button. It seems to me that in debug configuration works properly, but not in release configuration where the "first thread" never reach the wait and no event is thrown.

Answer 1

Your code could be a lot simpler than current version. Easiest way to make a non-blocking method for event is to mark it with async keyword and use the await keyword to start the asynchronous read operation from SerialPort.BaseStream property.

Also, CancellationTokenSource could be created with time, after that it get cancelled automatically, and the right way to cancel is to call CancellationToken.ThrowIfCancellationRequested method. async/await mechanism will invoke the event in UI context, so code could be something like this:

// async void is a recommended way to use asynchronous event handlers
private async void btnReadAll_Click(object sebder, EventArgs e)
{
    var data = new byte[2];

    // cancel source after 10 seconds
    var cts = new CancellationTokenSource(10000);
    // Read all information
    // [omit communication exchange via COM port]
    // async operation with BaseStream
    var result = await SerialPort.BaseStream.ReadAsync(data, 0, 2, cts.Token);

    /*
     * if you can't use the BaseStream methods, simply call this method here
     * cts.Token.ThrowIfCancellationRequested();
    */

    // this code would run only if everything is ok

    // check result here in your own way
    var boolFlag = result != null;

    ReadAllComplete?.Invoke(boolFlag);
}

Answer 2

Here's just a quick rewrite to remove the event and wrap what appears to be a synchronous IO API in an async one. If at all possible you should switch to a true async API and drop the Task.Run .

    private CancellationTokenSource cts;

    public async void MyButtonhandler(object sender, EventArgs e) {
        cts = new CancellationTokenSource();
        try {
            var result = await Task.Run(() => ReadAll(cts));
            if (result) {
                //success
            } else {
                //failure
            }
        } catch (TaskCanceledException ex) {

        }            
    }

    internal async Task<bool> ReadAll(CancellationTokenSource cts) {
        byte[] data = new byte[1];
        var timeout = TimeSpan.FromSeconds(10);

        var ReadAllTask = Task.Run(() => {
            // Read all information
            // [omit communication exchange via COM port]

        }, cts.Token);

        if (await Task.WhenAny(ReadAllTask, Task.Delay(timeout)) == ReadAllTask) {
            return true;
        }
        cts.Cancel();
        return false;
    }

Answer 3

Reading comments and answers to my question I learned a couple of useful things that solve my problem:

• CancellationTokenSource can have an implicit timeout
• use Task.Run instead Task.Factory.StartNew
• don't need to cancel the task, the cts will do the work

Now my code is simpler and it works:

private void Read_All_Button_Click(object sender, RoutedEventArgs e)
{
    // Start timedout task that will send all necessary commands
    CancellationTokenSource cts = new CancellationTokenSource(10000);
    Task.Run(() =>
    {
        oCommandSets.ReadAll(cts);
    }, cts.Token);
}

and

internal void ReadAll(CancellationTokenSource cts)
{
     // [communication]

     if (cts.IsCancellationRequested)
     {
         ReadAllComplete?.Invoke(false);
     }
     else
     {
         ReadAllComplete?.Invoke(true);
     }
}

In any case I need to learn more about multithreading.