C# async Deserializion method does not cancel

Question

I'm running into the issue where the task being executed below runs asynchronously but is unable to be cancelled when the serializer reads the memory stream. When the user makes the cancellation request (by pressing a cancel button), a cancellation (the method cancel() is called fromt he token) is made but the task continues.

Service Class:
Async method called from LoadHelper() in Main class

   public async void StartTask(Action callback, CancellationToken token)
    {
        await Task.Run(callback, token);
    }

Main Class:

    private void LoadHelper()
    {
        _services.GetInstance<IThreadService>().StartTask(
            () => LoadHelperAsync(), _cancelService.Token);
    }

Method being run async

    private void LoadHelperAsync()
    {
        var serializer = new DataContractSerializer(typeof(UserDatabase));
        string selectedDir;
        ComparisonResult = null;

        _services.GetInstance<IOpenFileService>().DisplayOpenFileDialog(
            "Select a saved comparison",
            "Comparison File(*.xml; *.cmp)|*.xml;*.cmp",
            Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
            out selectedDir);

        if (!string.IsNullOrEmpty(selectedDir))
        {
            _dispatchService.BeginInvoke(() => IsExecuting = true);
            using (FileStream fileStream = new FileStream(selectedDir, FileMode.Open, FileAccess.Read))
            using (DeflateStream compressedStream = new DeflateStream(fileStream, CompressionMode.Decompress))
            using (BufferedStream regularStream = new BufferedStream(fileStream))
            {
                Stream memoryStream;

                //Use filename to determine compression
                if (selectedDir.EndsWith(".cmp", true, null))
                {
                    memoryStream = compressedStream;
                }
                else
                {
                    memoryStream = regularStream;
                }

                Report("Loading comparison");

                Report(0);
                IsExecuting = true;
                ComparisonResult = (UserDatabase)serializer.ReadObject(memoryStream);

                memoryStream.Close();
                fileStream.Close();
                IsExecuting = false;
                Report("Comparison loaded");
            }
            _dispatchService.BeginInvoke(() => IsExecuting = false);
            _dispatchService.BeginInvoke(() => ViewResults.ExecuteIfAble());
        }
        else
        {
            Report("No comparison loaded");
        }

Cancellation code:

This command is binded to a "cancel" button in the view.

     CancelCompare = new Command(o => _cancelService.Cancel(), o => IsExecuting);

From the CancellationService class

    public class CancellationService : ICancellationService, IDisposable
{
    private CancellationTokenSource _tokenSource;

    public CancellationService()
    {
        Reset();
    }

    public CancellationToken Token { get; private set; }

    public void Cancel()
    {
        _tokenSource.Cancel();
    }

    public void Reset()
    {
        _tokenSource = new CancellationTokenSource();
        Token = _tokenSource.Token;
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            _tokenSource.Cancel();
            _tokenSource.Dispose();
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

Answer 1

Calling _tokenSource.Cancel(); won't do anything to a running task. A cancellation token interrupts task execution only if it was canceled before Task.Run

Take a look:

static void Main(string[] args)
{
    using (var tokenSource = new CancellationTokenSource())
    {
        var aTask = StartTask(() =>
        {
            while (true)
            {
                Console.WriteLine("Nothing is going to happen.");
                // Some long operation
                Thread.Sleep(1000);
            }
        }, tokenSource.Token);

        tokenSource.Cancel();
        aTask.Wait();
    }

    Console.ReadKey();
}

static async Task StartTask(Action callback, CancellationToken cancellationToken)
{
    await Task.Run(callback, cancellationToken);
}

If you want to cancel the execution, you should check the cancellation token by yourself, there is no any magic which cancels the task for you:

static void Main(string[] args)
{
    using (var tokenSource = new CancellationTokenSource())
    {
        var aTask = StartTask(cancellationToken =>
        {
            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();
                Console.WriteLine("Will stop before that if canceled.");
                // Some long operation
                // Also pass the token all way down
                Task.Delay(1000, cancellationToken).Wait();
            }
        }, tokenSource.Token);

        // Try 0, 500, 1500 to see the difference
        Thread.Sleep(1500);
        tokenSource.Cancel();

        try
        {
            aTask.Wait();
        }
        catch (Exception ex)
        {
            // AggregateException with OperationCanceledException
            Console.WriteLine("Task was canceled.");
            Console.WriteLine(ex.ToString());
        }
    }

    Console.ReadKey();
}

static async Task StartTask(Action<CancellationToken> callback, CancellationToken cancellationToken)
{
    await Task.Run(() => callback(cancellationToken), cancellationToken);
}

Note that this code only illustrates how the task works, never write anything like this in production.