c# - 根据任务状态(已完成/有故障)链接任务的正确方法

Question

我有一个操作列表和一个按钮。

当用户点击按钮时，操作按顺序执行。

每次操作完成时，它都会设置一个标志(更新 UI)，并继续执行下一个操作。

• 如果一个 Action 失败，所有剩余的 Action 将停止执行，并启动错误例程。

• 如果所有操作都成功，则启动成功例程。

假设:每个 Action 的执行都需要很长时间，并且必须在UI线程上执行

因为每个操作都是在 UI 线程上执行的，所以我使用 Tasks 来强制进行短暂的延迟，以允许 UI 在继续执行下一个操作之前进行更新。

我已经设法(以某种方式)使用 Tasks 并将它们链接在一起。

但我不确定这是正确的还是最好的方法，如果有人可以审查我的实现，我将不胜感激？

尝试代码:

• 检查所有项目并运行:所有项目应变为绿色，成功消息框

• 取消选中一个项目并运行:取消选中的项目变为红色，错误消息框，其余操作停止运行

Xaml:

<Window x:Class="Prototype.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:cv="clr-namespace:Prototype"
        Title="MainWindow" Height="450" Width="450">
    <DockPanel x:Name="RootGrid" >
        <!-- Run -->
        <Button Content="Run" 
                Click="OnRun"
                DockPanel.Dock="top" />

        <!-- Instructions -->
        <TextBlock DockPanel.Dock="Top"
                   Text="Uncheck to simulate failure"/>

        <!-- List of actions -->
        <ItemsControl ItemsSource="{Binding Actions}">
            <ItemsControl.ItemTemplate>
                <DataTemplate DataType="{x:Type cv:ActionVm}">
                    <Grid x:Name="BgGrid">
                        <CheckBox Content="Action" 
                                  IsChecked="{Binding IsSuccess,Mode=TwoWay}"/>
                    </Grid>
                    <DataTemplate.Triggers>
                        <!-- Success state -->
                        <DataTrigger Binding="{Binding State}" 
                                     Value="{x:Static cv:State.Success}">
                            <Setter TargetName="BgGrid"
                                    Property="Background"
                                    Value="Green" />
                        </DataTrigger>

                        <!-- Failure state -->
                        <DataTrigger Binding="{Binding State}" 
                                     Value="{x:Static cv:State.Failure}">
                            <Setter TargetName="BgGrid"
                                    Property="Background"
                                    Value="Red" />
                        </DataTrigger>
                    </DataTemplate.Triggers>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </DockPanel>
</Window>

代码隐藏:

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Prototype.Annotations;

namespace Prototype
{
    public partial class MainWindow
    {
        public MainViewModel Main { get; set; }

        public MainWindow()
        {
            // Caller injects scheduler to use when executing action
            Main = new MainViewModel(TaskScheduler.FromCurrentSynchronizationContext());
            InitializeComponent();
            DataContext = Main;
        }

        // User clicks on run
        private void OnRun(object sender, RoutedEventArgs e)
        {
            Main.RunAll();
        }
    }

    public class MainViewModel
    {
        private TaskScheduler ActionScheduler { get; set; }
        private TaskScheduler InternalUIScheduler { get; set; }

        // List of actions
        public ObservableCollection<ActionVm> Actions { get; set; }

        // Constructor
        // Injected Scheduler to use when executing an action
        public MainViewModel(TaskScheduler actionScheduler)
        {
            ActionScheduler = actionScheduler;
            InternalUIScheduler = TaskScheduler.FromCurrentSynchronizationContext();

            Actions = new ObservableCollection<ActionVm>();
            Actions.Add(new ActionVm());
            Actions.Add(new ActionVm());
            Actions.Add(new ActionVm()); // Mock exception.
            Actions.Add(new ActionVm());
            Actions.Add(new ActionVm());
        }

        // Runs all actions
        public void RunAll()
        {
            // Reset state
            foreach(var action in Actions) action.State = State.Normal;

            // Run
            RunAction();
        }

        // Recursively chain actions
        private void RunAction(int index=0, Task task=null)
        {

            if (index < Actions.Count)
            {
                ActionVm actionVm = Actions[index];
                if (task == null)
                {
                    // No task yet. Create new.
                    task = NewRunActionTask(actionVm);
                }
                else
                {
                    // Continue with
                    task = ContinueRunActionTask(task, actionVm);
                }

                // Setup for next action (On completed)
                // Continue with a sleep on another thread (to allow the UI to update)
                task.ContinueWith(
                    taskItem => { Thread.Sleep(10); }
                    , CancellationToken.None
                    , TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnRanToCompletion
                    , TaskScheduler.Default)

                    .ContinueWith(
                        taskItem => { RunAction(index + 1, taskItem); }
                        , CancellationToken.None
                        , TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnRanToCompletion
                        , TaskScheduler.Default);

                // Setup for error (on faulted)
                task.ContinueWith(
                    taskItem =>
                    {
                        if (taskItem.Exception != null)
                        {
                            var exception = taskItem.Exception.Flatten();
                            var msg = string.Join(Environment.NewLine, exception.InnerExceptions.Select(e => e.Message));
                            MessageBox.Show("Error routine: " + msg);
                        }
                    }
                    , CancellationToken.None
                    , TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnFaulted
                    , InternalUIScheduler);
            }
            else
            {
                // No more actions to run
                Task.Factory.StartNew(() =>
                {
                    new TextBox(); // Mock final task on UI thread
                    MessageBox.Show("Success routine");
                }
                    , CancellationToken.None
                    , TaskCreationOptions.AttachedToParent
                    , InternalUIScheduler);
            }
        }


        // Continue task to run action
        private Task ContinueRunActionTask(Task task, ActionVm action)
        {
            task = task.ContinueWith(
                taskItem => action.Run()
                , CancellationToken.None
                , TaskContinuationOptions.AttachedToParent
                , ActionScheduler);
            return task;
        }

        // New task to run action
        public Task NewRunActionTask(ActionVm action)
        {
            return Task.Factory.StartNew(
                action.Run 
                , CancellationToken.None
                , TaskCreationOptions.AttachedToParent
                , ActionScheduler);
        }
    }

    public class ActionVm:INotifyPropertyChanged
    {
        // Flag to mock if the action executes successfully
        public bool IsSuccess
        {
            get { return _isSuccess; }
            set { _isSuccess = value;  OnPropertyChanged();}
        }

        // Runs the action
        public void Run()
        {
            if (!IsSuccess)
            {
                // Mock failure. 
                // Exceptions propagated back to caller.

                // Update state (view)
                State = State.Failure;
                throw new Exception("Action failed");
            }
            else
            {
                // Mock success
                // Assumes that the action is always executed on the UI thread
                new TextBox();
                Thread.Sleep(1000);

                // Update state (view)
                State = State.Success;
            }
        }

        private State _state;
        private bool _isSuccess = true;

        // View affected by this property (via triggers)
        public State State
        {
            get { return _state; }
            set { _state = value; OnPropertyChanged(); }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public enum State
    {
        Normal,
        Success,
        Failure
    }

}

[更新 1]

澄清一下，在示例代码中，ActionVm 被假定为一个黑盒。它的 Run() 方法被认为是 UI 线程上的一个耗时操作，完成后会自动设置其内部 State 属性(view bounded)。

我唯一可以修改/控制的类是 MainViewModel(运行每个任务，然后是成功/失败例程)。

如果我所做的只是一个 foreach-Run()，UI 将被锁定，并且在所有操作完成之前没有可见的操作状态更改反馈。

因此，我试图在执行操作之间添加一个非 UI 延迟，以允许绑定(bind)到 ActionVm.State 的 View 至少在下一次阻塞运行之前重绘。

ActionVms 是长时间运行的操作，会阻塞 UI 线程。这是它正常工作所必需的。至少我想做的是向用户提供一些视觉反馈，告诉他们事情仍在运行。

Answer 1

假设您正在执行的操作只需要在短时间内访问 UI(因此大部分时间都花在可以在任何线程上执行的计算上)，那么您可以使用 异步-等待。像这样的东西:

Func<Task> action1 = async () =>
{
    // start on the UI thread
    new TextBox();

    // execute expensive computation on a background thread,
    // so the UI stays responsive
    await Task.Run(() => Thread.Sleep(1000));

    // back on the UI thread
    State = State.Success;
};

然后像这样执行:

var actions = new[] { action1 };

try
{
    foreach (var action in actions)
    {
        await action();
    }

    MessageBox.Show("Success routine");
}
catch (Exception ex)
{
    MessageBox.Show("Error routine: " + ex.Message);
}

由于我在上面的代码中使用了 async-await，因此您需要一个 C# 5.0 编译器。