取消线程并重新启动它

Question

当用户调整窗口大小时，应该更新一些长文本，但如果线程已经在运行，它应该停止并使用新的宽度参数重新开始。

int myWidth;
private CancellationTokenSource tokenSource2 = new CancellationTokenSource();
private CancellationToken ct = new CancellationToken();

void container_Loaded(object sender, RoutedEventArgs e)
{
  ct = tokenSource2.Token;
  MyFunction();
}

        void container_SizeChanged(object sender, SizeChangedEventArgs e)
        {
          if (tokenSource2.Token.IsCancellationRequested)
            MyFunction();
          else
            tokenSource2.Cancel();
        }

        void MyFunction()            
        {
           myWidth = GetWidth();
           Task.Factory.StartNew(() =>
           {  
              string s;    
              for (int i=0;i<1000,i++){
                  s=s+Functionx(myWidth);
                  ct.ThrowIfCancellationRequested();
              }
              this.Dispatcher.BeginInvoke(new Action(() => { 
                   ShowText(s); 
              }));
           },tokenSource2.Token)
           .ContinueWith(t => {
              if (t.IsCanceled)
              {
                tokenSource2 = new CancellationTokenSource(); //reset token
                MyFunction(); //restart
              };
           });
        }

现在发生的情况是，当我调整窗口大小时，我看到文本在接下来的几秒钟内迭代更新，就好像旧线程没有被取消一样。我做错了什么？

Answer 1

我认为在这种情况下使用全局变量不是一个好主意。下面是我如何通过从a related question 向我的AsyncOp 类添加取消逻辑来做到这一点。此代码还实现了the IProgress pattern 并限制了 ViewModel 更新。

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;

namespace Wpf_21611292
{
    /// <summary>
    /// Cancel and restarts an asynchronous operation
    /// </summary>
    public class AsyncOp<T>
    {
        readonly object _lock = new object();
        Task<T> _pendingTask = null;
        CancellationTokenSource _pendingCts = null;

        public Task<T> CurrentTask
        {
            get { lock (_lock) return _pendingTask; }
        }

        public bool IsPending
        {
            get { lock (_lock) return _pendingTask != null && !_pendingTask.IsCompleted; }
        }

        public bool IsCancellationRequested
        {
            get { lock (_lock) return _pendingCts != null && _pendingCts.IsCancellationRequested; }
        }

        public void Cancel()
        {
            lock (_lock)
            {
                if (_pendingTask != null && !_pendingTask.IsCompleted && !_pendingCts.IsCancellationRequested)
                    _pendingCts.Cancel();
            }
        }

        public Task<T> Run(
            Func<CancellationToken, Task<T>> routine,
            CancellationToken token = default,
            bool startAsync = false,
            bool continueAsync = false,
            TaskScheduler taskScheduler = null)
        {
            Task<T> previousTask = null;
            CancellationTokenSource previousCts = null;

            Task<T> thisTask = null;
            CancellationTokenSource thisCts = null;

            async Task<T> routineWrapper()
            {
                // await the old task
                if (previousTask != null)
                {
                    if (!previousTask.IsCompleted && !previousCts.IsCancellationRequested)
                    {
                        previousCts.Cancel();
                    }
                    try
                    {
                        await previousTask;
                    }
                    catch (Exception ex)
                    {
                        if (!(previousTask.IsCanceled || ex is OperationCanceledException))
                            throw;
                    }
                }

                // run and await this task
                return await routine(thisCts.Token);
            };

            Task<Task<T>> outerTask;

            lock (_lock)
            {
                previousTask = _pendingTask;
                previousCts = _pendingCts;

                thisCts = CancellationTokenSource.CreateLinkedTokenSource(token);

                outerTask = new Task<Task<T>>(
                    routineWrapper,
                    thisCts.Token,
                    continueAsync ?
                        TaskCreationOptions.RunContinuationsAsynchronously :
                        TaskCreationOptions.None);

                thisTask = outerTask.Unwrap();

                _pendingTask = thisTask;
                _pendingCts = thisCts;
            }

            var scheduler = taskScheduler;
            if (scheduler == null)
            {
                scheduler = SynchronizationContext.Current != null ?
                    TaskScheduler.FromCurrentSynchronizationContext() :
                    TaskScheduler.Default;
            }

            if (startAsync)
                outerTask.Start(scheduler);
            else
                outerTask.RunSynchronously(scheduler);

            return thisTask;
        }
    }

    /// <summary>
    /// ViewModel
    /// </summary>
    public class ViewModel : INotifyPropertyChanged
    {
        string _width;

        string _text;

        public string Width
        {
            get
            {
                return _width;
            }
            set
            {
                if (_width != value)
                {
                    _width = value;
                    this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Width)));
                }
            }
        }

        public string Text
        {
            get
            {
                return _text;
            }
            set
            {
                if (_text != value)
                {
                    _text = value;
                    this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Text)));
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

    /// <summary>
    /// MainWindow
    /// </summary>
    public partial class MainWindow : Window
    {
        ViewModel _model = new ViewModel { Text = "Starting..." };

        AsyncOp<DBNull> _asyncOp = new AsyncOp<DBNull>();

        CancellationTokenSource _workCts = new CancellationTokenSource();

        public MainWindow()
        {
            InitializeComponent();
            this.DataContext = _model;

            this.Loaded += MainWindow_Loaded;
            this.SizeChanged += MainWindow_SizeChanged;
        }

        void MainWindow_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            _asyncOp.Run(WorkAsync, _workCts.Token);
        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            _asyncOp.Run(WorkAsync, _workCts.Token);
        }

        async Task<DBNull> WorkAsync(CancellationToken token)
        {
            const int limit = 200000000;
            var throttle = TimeSpan.FromMilliseconds(200);

            // update ViewModel's Width
            _model.Width = $"Width: {this.Width:#.##}";

            // update ViewModel's Text using IProgress pattern 
            // and throttling updates
            IProgress<int> progress = new Progress<int>(i =>
            {
                _model.Text = $"{(double)i / (limit - 1)* 100:0.}%";
            });

            var stopwatch = new Stopwatch();
            stopwatch.Start();

            // do some CPU-intensive work
            await Task.Run(() =>
            {
                int i;
                for (i = 0; i < limit; i++)
                {
                    if (stopwatch.Elapsed > throttle)
                    {
                        progress.Report(i);
                        stopwatch.Restart();
                    }
                    if (token.IsCancellationRequested)
                        break;
                }
                progress.Report(i);
            }, token);

            return DBNull.Value;
        }
    }
}

XAML：

<Window x:Class="Wpf_21611292.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <TextBox Width="200" Height="30" Text="{Binding Path=Width}"/>
        <TextBox Width="200" Height="30" Text="{Binding Path=Text}"/>
    </StackPanel>
</Window>

它使用async/await，所以如果你的目标是.NET 4.0，你需要Microsoft.Bcl.Async和VS2012+。或者，您可以将 async/await 转换为 ContinueWith，这有点乏味，但总是可以的（这或多或少是 C# 5.0 编译器在幕后所做的）。

Answer 2

您应该使用 Microsoft 的响应式框架（又名 Rx） - NuGet System.Reactive.Windows.Threading（用于 WPF）并添加 using System.Reactive.Linq; - 然后您可以这样做：

    public MainWindow()
    {
        InitializeComponent();

        _subscription =
            Observable
                .FromEventPattern<SizeChangedEventHandler, SizeChangedEventArgs>(
                    h => container.SizeChanged += h,
                    h => container.SizeChanged -= h)
                .Select(e => GetWidth())
                .Select(w => Observable.Start(
                        () => String.Concat(Enumerable.Range(0, 1000).Select(n => Functionx(w)))))
                .Switch()
                .ObserveOnDispatcher()
                .Subscribe(t => ShowText(t));
    }

    private IDisposable _subscription = null;

这就是所有需要的代码。

这会响应SizeChanged 事件，调用GetWidth，然后将Functionx 推送到另一个线程。它使用Switch() 始终切换到最新的SizeChanged，然后忽略任何正在进行的代码。它将结果推送到调度程序，然后调用ShowText。

如果您需要关闭表单或停止订阅运行，只需致电_subscription.Dispose()。

简单。