CODEWITHSUNDEEP
c#wpfmultithreadingbackgroundworker
Aks
Aks

Reputation: 5236

WPF/C# Cancelling BackgroundWorker call outside DoWork

I have a BackgroundWorker DoWork function as follows

    private void WorkerGetFeedData(object sender, DoWorkEventArgs args)
    {
            _feed.FetchUserData(_userNameCollection);
    }

The FetchUserData is a function in another class(whose object is _feed) in another project in the same solution. The data fetch process takes considerable time and I'd like for the user to be able to cancel the process if necessary. How do I convey a cancel operation from the user to a function call elsewhere and just stop it?

Upvotes: 2

Views: 2416

Answers (2)

OsQu
OsQu

Reputation: 1058

You can use BackgroundWorker.CancelAsync method. Here's more info with example: MSDN

To be more exact to your problem, pass the worker to FetchUserData. It is the sender parameter. Then in the FetchUserData function you can check if the flag BackgroundWorker.CancellationPending is set and finish your method.

void FetchUserData(IEnumerable<Users> userNameCollection, BackgroundWorker worker)
{
    // ...

    if(worker.CancellationPending)
    {
        // Finish method..
    }
}

And the WorkerGetFeedData method:

private void WorkerGetFeedData(object sender, DoWorkEventArgs args)
{
        var worker = sender as BackgroundWorker;
        if(worker != null)
            _feed.FetchUserData(_userNameCollection, worker);
}

Upvotes: 4

Sascha Hennig
Sascha Hennig

Reputation: 2572

Send a message (event) to the worker thread that changes a boolean, indicating that the worker thread should end/cancel itself.

Edit: I was a bit quick reading your question, missing the important part. While trying to make up I found this interesting article which might help:

http://ondotnet.com/pub/a/dotnet/2003/02/18/threadabort.html

It does work when simulating a long running process with Thread.Sleep(), being at work I dont have time right now to write code to test it on a proper application/long running task.

class Program
{
    static void Main(string[] args)
    {
        Thread thread = new Thread(new ThreadStart(Foo));
        thread.Start();
        Console.ReadKey();
        thread.Abort(); // cause ThreadAbortException to be thrown    
        Console.ReadKey();
    }

    static void Foo()
    {
        try
        {
            while( true )
            {
                Console.WriteLine("Long running process...");
                Thread.Sleep(100000);
            }
        }
        catch( ThreadAbortException ex )
        {
            Console.WriteLine(ex.Message);
        }
        finally 
        {
            Console.WriteLine("Thread Closing ...");
        }
    }
}

The problem with this approach is - it uses Thread.Abort() - which interrupts the thread no matter what it is doing. This can lead to left open handles, memory leaks, etc. So while it may help it would most likely be very unwise to use.

Ian Griffiths supposes that another way to (force) cancel a thread would be to run it in its own, seperate process: http://www.interact-sw.co.uk/iangblog/2004/11/12/cancellation which you can kill whenever without affecting your process's internal state.

Upvotes: 0

Related Questions