Executing a method simultaneously to program window and stop it anytime

Question

I need a functionality that will allow to execute method in a background and leave window responsive, but I need to have a possibility to stop or suspend it anytime. I know that threads are partly answer to my question, but unfortunately there is no way to stop thread from executing a time-absorbing block of code just like that. I had thoughts about process communication, but is it a good idea? Or maybe there is a way to terminate a thread unconditionally?

Answer 1

The only option that you have, if it's important that you can always stop the code at any point in it's execution, and when you can't have cooperative cancellation on the part of the worker, then you need to have a separate process. It is the most reliable way of stopping the execution of code in the manor you've described. It cannot be reliably done using Threads.

Answer 2

It seems that you're looking for BackgroundWorker .

You'll have to check in the second thread if the main thread is asking it to stop, and do so if needed.

Simple (tested) example:

public partial class Form1 : Form
{
    BackgroundWorker w = new BackgroundWorker();

    public Form1()
    {
        InitializeComponent();
        w.WorkerSupportsCancellation = true;
        w.DoWork += new DoWorkEventHandler(w_DoWork);
        w.RunWorkerAsync();
    }

    void w_DoWork(object sender, DoWorkEventArgs e)
    {
        for (int i = 0; i < 10000000000; i++)
        {
            if (w.CancellationPending)
            {
                MessageBox.Show("Cancelled");
                break;
            }
            //Do things...
        }
    }

    private void button1_Click(object sender, EventArgs e)
    {
        w.CancelAsync();
    }
}

EDIT

If you're speaking of an HTTP request, perhaps: HttpWebRequest.Abort? (Though see this answer.)

Answer 3

As stated in comments thread.Abort() is an option, but not advised. Rather you should be using thread.Interrupt() and the reasons for that are well detailed here.

The reason you should not kill a thread instantly is because it could cause a lock being set, but never unset due to the fact that the code was suddenly stopped with no path out. So if it locks code that you will need to reuse, there would be no way to unlock it from the previous call. Obviously, you could build around this, but I'm assuming you are using blocking code that isn't built from the ground up by you.

You could do it in a separate process and kill the process with much less risk, but then passing the data back and forth and the added mess becomes complicated.

Here is an example of using an external process to do this chuck and being able to kill the process will less risk.

public class Main
{
    public Main()
    {
        //In use
        DoCalculation calc = new DoCalculation();
        calc.StartCalculation(123, 188, ReceivedResults);

        //Cancel after 1sec
        Thread.Sleep(1000);
        calc.CancelProcess();
    }

    public void ReceivedResults(string result)
    {
        Console.WriteLine(result);
    }
}
public class DoCalculation
{
    private System.Diagnostics.Process process = new System.Diagnostics.Process();
    private Action<string> callbackEvent;
    public void StartCalculation(int var1, int var2, Action<string> CallbackMethod)
    {
        callbackEvent = CallbackMethod;
        string argument = "-v1 " + var1 + " -v2 " + var2;
        //this is going to run a separate process that you'll have to make and
        //you'll need to pass in the argument via command line args. 
        RunProcess("calcProc.exe", argument);
    }
    public void RunProcess(string FileName, string Arguments)
    {
        SecurityPermission SP = new SecurityPermission(SecurityPermissionFlag.Execution);
        SP.Assert();
        process.StartInfo.UseShellExecute = false;
        process.StartInfo.RedirectStandardOutput = true;
        process.StartInfo.RedirectStandardError = true;
        process.StartInfo.CreateNoWindow = true;
        process.StartInfo.FileName = FileName;
        process.StartInfo.Arguments = Arguments;
        process.StartInfo.WorkingDirectory = "";
        process.OutputDataReceived += ProcessCompleted;
        process.Start();
    }

    public void CancelProcess()
    {
        if (process != null)
            process.Kill();
    }

    private void ProcessCompleted(object sender, DataReceivedEventArgs e)
    {
        string result = e.Data;
        if (callbackEvent != null)
        {
            callbackEvent.Invoke(result);
        }
    }
}

Can you give us any more details on exactly what you are doing? Perhaps there are better alternatives to this problem.