What is the best way to cancel operation anywhere in a method?

Question

Suppose I have a long operation inside a subroutine or function and I want to be able to cancel (exit subroutine or function) immediately after a "cancellation flag" is set to true. What is the best way to do it? One way is to check the flag after each line of code but that is not very elegant.

For example:

dim _CancelFlag as boolean = false

Sub LongOperation()
    dim a as integer

    a = 1
    if _CancelFlag = True Then
        Exit Sub
    End If

    a = 2
    if _CancelFlag = True Then
        Exit Sub
    End If

    'And so on...
End Sub

Of course a = 1 is only for illustration purpose. Say the operation is really long until a = 100 and it is not possible to put them into a loop, how can I trigger the cancellation from outside of the subroutine and stop it immediately?

I was thinking to put the sub into a BackgroundWorker or Task but then I still have to check for CancellationToken somewhere inside the sub.. Do I really have to check after each line of code?

Answer 1

It depends on the granularity you want to achieve: how many seconds can you expect your method be canceled?

If the cancellation must take place "immediately" you have to check in as many place as you can. However, just checking before and after long sub steps of your operation is enough in the general case.

Remember that if you have to wait on handles, you have to use the appropriate overload that specifies a timeout or a cancellation token.

Additionally, you should propagate the cancellation token/your flag deep down your methods to allow detection early the cancellation requests.

Answer 2

I found a more elegant way to do it, although it does use a loop in the end. Please let me know if anybody has an better solution. I will also update when I find something else.

Sub LongOperation()
    dim state as integer = 0

    Do while state < 100
        Select Case state
            Case 0
                a = 1
            Case 1
                a = 2
            Case Else
                Exit do
        End Select

        If _CancelFlag = True Then
            Exit Sub
        End If

        state += 1
    Loop

End Sub

Answer 3

This is a sample windows application I have created to cancel or pause the log running task.

public partial class Form1 : Form
    {
        updateUI _updateGUI;
        CancellationToken _cancelToken;
        PauseTokenSource _pauseTokeSource;
        public Form1()
        {
            InitializeComponent();
        }


        delegate void updateUI(dynamic value);

        private void btnStartAsync_Click(object sender, EventArgs e)
        {
            _pauseTokeSource = new PauseTokenSource();
            _cancelToken = default(CancellationToken);

            _pauseTokeSource.onPause -= _pauseTokeSource_onPause;
            _pauseTokeSource.onPause += _pauseTokeSource_onPause;

            Task t = new Task(() => { LongRunning(_pauseTokeSource); }, _cancelToken);
            t.Start();

        }

        private void _pauseTokeSource_onPause(object sender, PauseEventArgs e)
        {
            var message = string.Format("Task {0} at {1}", e.Paused ? "Paused" : "Resumed", DateTime.Now.ToString());
            this.Invoke(_updateGUI, message);
        }

        private async void LongRunning(PauseTokenSource pause)
        {
            _updateGUI = new updateUI(SetUI);
            for (int i = 0; i < 20; i++)
            {

                await pause.WaitWhilePausedAsync();

                Thread.Sleep(500);
                this.Invoke(_updateGUI, i.ToString() + " => " + txtInput.Text);

                //txtOutput.AppendText(Environment.NewLine + i.ToString());


                if (_cancelToken.IsCancellationRequested)
                {
                    this.Invoke(_updateGUI, "Task cancellation requested at " + DateTime.Now.ToString());
                    break;
                }
            }
            _updateGUI = null;
        }


        private void SetUI(dynamic output)
        {
            //txtOutput.AppendText(Environment.NewLine + count.ToString() + " => " + txtInput.Text);
            txtOutput.AppendText(Environment.NewLine + output.ToString());
        }

        private void btnCancelTask_Click(object sender, EventArgs e)
        {
            _cancelToken = new CancellationToken(true);
        }

        private void btnPause_Click(object sender, EventArgs e)
        {
            _pauseTokeSource.IsPaused = !_pauseTokeSource.IsPaused;
            btnPause.Text = _pauseTokeSource.IsPaused ? "Resume" : "Pause";
        }
}

 public class PauseTokenSource
    {
        public delegate void TaskPauseEventHandler(object sender, PauseEventArgs e);
        public event TaskPauseEventHandler onPause;

        private TaskCompletionSource<bool> _paused;
        internal static readonly Task s_completedTask = Task.FromResult(true);

        public bool IsPaused
        {
            get { return _paused != null; }
            set
            {

                if (value)
                {
                    Interlocked.CompareExchange(ref _paused, new TaskCompletionSource<bool>(), null);
                }
                else
                {
                    while (true)
                    {
                        var tcs = _paused;
                        if (tcs == null) return;
                        if (Interlocked.CompareExchange(ref _paused, null, tcs) == tcs)
                        {
                            tcs.SetResult(true);
                            onPause?.Invoke(this, new PauseEventArgs(false));
                            break;
                        }
                    }
                }
            }
        }

        public PauseToken Token
        {
            get
            {
                return new PauseToken(this);
            }
        }

        internal Task WaitWhilePausedAsync()
        {
            var cur = _paused;

            if (cur != null)
            {
                onPause?.Invoke(this, new PauseEventArgs(true));
                return cur.Task;
            }
            return s_completedTask;
        }
    }

    public struct PauseToken
    {
        private readonly PauseTokenSource m_source;
        internal PauseToken(PauseTokenSource source) { m_source = source; }

        public bool IsPaused { get { return m_source != null && m_source.IsPaused; } }

        public Task WaitWhilePausedAsync()
        {
            return IsPaused ?
                m_source.WaitWhilePausedAsync() :
                PauseTokenSource.s_completedTask;
        }
    }

    public class PauseEventArgs : EventArgs
    {
        public PauseEventArgs(bool paused)
        {
            Paused = paused;
        }
        public bool Paused { get; private set; }
    }

Answer 4

If your LongOperation() is well splittable into short operations (I assume a=1, a=2, ..., a=100 being all reasonably short) than you could wrap all the short operations into Tasks, put them into a TaskQueue and process that queue, checking between the Tasks if cancellation was requested.

If LongOperation() is difficult to split you could run the LongOperation() on a separate dedicated thread and abort that thrad on cancellation. Some have commented aborting a thread being dirty and not being recommended. Actually that's not that bad, if properly handled. Aborting a thread just raises a ThradAbortException within the thread method. So if there is a try - catch - finally in the LongOperation(), catching and handling the exception and if the finally code properly does cleanup, closes all handles, disposes etc., this should be ok and nothing to be afraid of.