在方法中的任何位置取消操作的最佳方法是什么？

Question

假设我在一个子例程或函数中有一个长操作，并且我希望能够在“取消标志”设置为真后立即取消（退出子例程或函数）。最好的方法是什么？一种方法是在每行代码之后检查标志，但这不是很优雅。

例如：

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

当然a = 1 仅用于说明目的。假设操作真的很长，直到a = 100 并且不可能将它们放入循环中，我如何从子程序外部触发取消并立即停止它？

我正在考虑将 sub 放入 BackgroundWorker 或 Task，但我仍然需要检查 sub 内部某处的 CancellationToken。我真的必须在每一行代码之后检查吗？

Answer 1

这取决于您想要达到的粒度：您希望您的方法取消多少秒？

如果必须“立即”取消，您必须在尽可能多的地方办理登机手续。但是，在一般情况下，只需检查操作的长子步骤之前和之后就足够了。

请记住，如果您必须等待句柄，则必须使用指定超时或取消令牌的适当重载。

此外，您应该在方法的深处传播取消令牌/您的标志，以便及早检测取消请求。

Answer 2

我找到了一种更优雅的方法，尽管它最终确实使用了循环。请让我知道是否有人有更好的解决方案。当我发现其他东西时，我也会更新。

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

这是我创建的一个示例 Windows 应用程序，用于取消或暂停日志运行任务。

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

如果您的 LongOperation() 可以很好地拆分为短操作（我假设 a=1、a=2、...、a=100 都相当短），那么您可以将所有短操作包装到任务中，将它们放入进入任务队列并处理该队列，检查任务之间是否请求取消。

如果 LongOperation() 难以拆分，您可以在单独的专用线程上运行 LongOperation() 并在取消时中止该线程。有些人评论说中止线程很脏并且不被推荐。如果处理得当，其实这并没有那么糟糕。中止线程只会在线程方法中引发 ThradAbortException。因此，如果 LongOperation() 中有 try - catch - finally，则捕获并处理异常，并且 finally 代码是否正确进行了清理，关闭所有句柄，处理等，这应该没问题，没什么好害怕的。