Cancelling a background worker immediately in the middle of an operation

Question

I am trying to understand what I can and cant do with background workers. I have seen a fair amount of posts on this but it all seems to involve some operation with loops and you cancel an operation within a loop. I am wanting to find out if I can cancel some operation on a background worker without a loop.
I have the following simple form that I'm playing with:

which contains the following code:

string[,] TestData = new string[300000, 100];
List<string> TestDataList;
private static Random random = new Random();

public Form1()
{
    InitializeComponent();
    // Loading up some fake data
    for (int i = 0; i < 300000; i++)
    {
        for (int j = 0; j < 100; j++)
        {
            this.TestData[i, j] = RandomString(10) + j.ToString();
        }
    }
}
public static string RandomString(int length)
{
    const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    return new string(Enumerable.Repeat(chars, length)
      .Select(s => s[random.Next(s.Length)]).ToArray());
}

which loads a string array with a lot of dummy data. The start button method is as follows:

private void StartWork_Click(object sender, EventArgs e)
{
    try
    {
        System.Threading.SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
        BackgroundWorker bw = new BackgroundWorker();
        bw.DoWork += new DoWorkEventHandler(bw_DoWork);
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_Complete);
        bw.RunWorkerAsync();
    }
    catch (Exception ex)
    {
        MessageBox.Show("Something went wrong.\nError:" + ex.Message);
    }
}

And I also have:

private void bw_DoWork(object sender, DoWorkEventArgs e)
{
    this.TestDataList = this.TestData.Cast<string>()
    .Select((s, i) => new { GroupIndex = i / 100, Item = s.Trim().ToLower() })
    .GroupBy(g => g.GroupIndex)
    .Select(g => string.Join(",", g.Select(x => x.Item))).ToList();

}

private void bw_Complete(object sender, RunWorkerCompletedEventArgs e)
{
    this.showWorkingLabel.Text = "Work done";
}

private void btnCancel_Click(object sender, EventArgs e)
{
    // I want to cancel the work with this button


    // Then show
    this.showWorkingLabel.Text = "Work Cancelled";
}

So you'll notice that my bw_DoWork method does not contain any loops, just a single operation and I want to know if:

1. If I can kill/cancel the background worker by clicking the Cancel button while the following code is being executed:

    .Select((s, i) => new { GroupIndex = i / 100, Item = s.Trim().ToLower() })
    .GroupBy(g => g.GroupIndex)
    .Select(g => string.Join(",", g.Select(x => x.Item))).ToList();

2. Can I update the label showWorkingLabel while the background work is happening so that it continuously shows ".", "..", "..." and then back to "." like a progress bar to indicate work is still happening

Answer 1

You need first to support cancellation

bw.WorkerSupportsCancellation = true;

Then you need to share a cancellation token at form level

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken cancellationToken;

Inside your work you need to throw the cancellation:

cancellationToken.ThrowIfCancellationRequested();

Or handle it gracefully with the background worker even for pending cancellations: BackgroundWorker.CancellationPending

And in the cancell button you can call the cancellation like this:

cts.Cancel();

Using your code it will become something similar to the following indication, you should handle graceful cancellations:

    string[,] TestData = new string[30000, 100];
    List<string> TestDataList;
    private static Random random = new Random();
    CancellationTokenSource cts = new CancellationTokenSource();
    CancellationToken cancellationToken;

    private void BtnStart_Click(object sender, EventArgs e)
    {
        try
        {
            this.showWorkingLabel.Text = "Work start";
            System.Threading.SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
            BackgroundWorker bw = new BackgroundWorker();
            bw.WorkerSupportsCancellation = true;
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);

            cancellationToken = cts.Token;
            cancellationToken.Register(bw.CancelAsync);

            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_Complete);
            bw.RunWorkerAsync();

        }
        catch (Exception ex)
        {
            MessageBox.Show("Something went wrong.\nError:" + ex.Message);
        }
    }

    private void bw_DoWork(object sender, DoWorkEventArgs e)
    {
        cancellationToken.ThrowIfCancellationRequested();
        this.TestDataList = this.TestData
            .Cast<string>()
            .Select((s, i) => new { GroupIndex = i / 100, Item = s.Trim().ToLower() })
            .GroupBy(g => g.GroupIndex)
            .Select(g =>
            {
                cancellationToken.ThrowIfCancellationRequested();
                return string.Join(",", g.Select(x => x.Item));
            })
            .ToList();
    }

    private void btnCancel_Click(object sender, EventArgs e)
    {
        cts.Cancel();

        this.showWorkingLabel.Text = "Work Cancelled";
    }

Answer 2

Here is a working example using the BackgroundWorker builtin cancellation support.

// We need to remember the BackgroundWorker
private BackgroundWorker bw;

private void StartWork_Click( object sender, EventArgs e )
{
    bw = new BackgroundWorker
    {
        WorkerSupportsCancellation = true,
    };

    bw.DoWork += Bw_DoWork;
    bw.RunWorkerCompleted += Bw_RunWorkerCompleted;
    bw.RunWorkerAsync();

    showWorkingLabel.Text = "Work started ...";
}

private void Bw_RunWorkerCompleted( object sender, RunWorkerCompletedEventArgs e )
{
    if ( e.Cancelled ) // was it cancelled?
    {
        showWorkingLabel.Text = "Work cancelled.";
        return;
    }

    if ( e.Error != null ) // any error?
    {
        showWorkingLabel.Text = "Work faulted - " + e.Error.Message;
        return;
    }
    // assign the bw Result to the field
    this.TestDataList = (List<string>)e.Result;
    showWorkingLabel.Text = "Work completed.";
}

private void Bw_DoWork( object sender, DoWorkEventArgs e )
{
    try
    {
        e.Result = this.TestData
            .Cast<string>()
            .Select( ( s, i ) =>
            {
                // check for cancellation
                if ( bw.CancellationPending )
                    throw new OperationCanceledException();
                return new
                {
                    GroupIndex = i / 100,
                    Item = s.Trim().ToLower()
                };
            } )
            .GroupBy( g => g.GroupIndex )
            .Select( g =>
            {
                // check for cancellation
                if ( bw.CancellationPending )
                    throw new OperationCanceledException();
                return string.Join( ",", g.Select( x => x.Item ) );
            } )
            .ToList();
    }
    catch ( OperationCanceledException )
    {
        e.Cancel = true;
    }
}

private void btnCancel_Click( object sender, EventArgs e )
{
    // request cancellation
    bw.CancelAsync();
    showWorkingLabel.Text = "Work cancellation requested ...";
}

and another doing exactly the same with the modern async/await Task and CancellationToken

private CancellationTokenSource cts;

private async void StartWork_Click( object sender, EventArgs e )
{
    showWorkingLabel.Text = "Work started ...";
    cts = new CancellationTokenSource();
    var token = cts.Token;

    try
    {
        TestDataList = await Task.Run( () =>
        {
            return this.TestData
                .Cast<string>()
                .Select( ( s, i ) =>
                {
                    token.ThrowIfCancellationRequested();
                    return new
                    {
                        GroupIndex = i / 100,
                        Item = s.Trim().ToLower()
                    };
                } )
                .GroupBy( g => g.GroupIndex )
                .Select( g =>
                {
                    token.ThrowIfCancellationRequested();
                    return string.Join( ",", g.Select( x => x.Item ) );
                } )
                .ToList();
        }, token );
        showWorkingLabel.Text = "Work completed.";
    }
    catch ( OperationCanceledException )
    {
        showWorkingLabel.Text = "Work canceled.";
    }
    catch ( Exception ex )
    {
        showWorkingLabel.Text = "Work faulted - " + ex.Message;
    }

}

private void btnCancel_Click( object sender, EventArgs e )
{
    cts.Cancel();
    showWorkingLabel.Text = "Work cancellation requested ...";
}

Answer 3

As per the MSDN page for BackgroundWorker:

When creating the worker, you can make it support cancellation by setting

backgroundWorker.WorkerSupportsCancellation = true;

You can request cancellation by calling CancelAsync() on the BackgroundWorker.

Then your BackgroundWorker should periodically check the BackgroundWorker.CancellationPending property, and if set to true, it should cancel its operation. As Sir Rufo pointed out in a comment, don't forget to inside the DoWork delegate you have to set DoWorkEventArgs.Cancel to true.

The MSDN page I linked has additional examples of usage in real code.