2

至少当我在我的代码中实现它时，我必须修改 StartNew Task 以获得相同的行为。在我的视图中有一个开始按钮。它的 IsEnabled 属性绑定到视图模型中的布尔值。在没有添加await task.ContinueWith(_ => true);和return true;移出 try 块的情况下，PopulateListStartNew 任务不会等待，因此按钮保持启用状态。我更喜欢使用Task.Factory.StartNew，因为传递 TaskScheduler 会使代码更具可读性（没有 Dispatcher 混乱）。Records 是一个 ObservableCollection。

我认为 Task.Run 基本上是一个快捷方式（每个Task.Run 与 Task.Factory.StartNew。无论如何，我想更好地理解行为上的差异，并且肯定会感谢与使我的示例代码更好有关的任何建议.

public async Task<bool> PopulateListTaskRun(CancellationToken cancellationToken)
{
    try
    {
        await Task.Run(async () =>
            {
                // Clear the records out first, if any
                Application.Current.Dispatcher.InvokeAsync(() => Records.Clear());


                for (var i = 0; i < 10; i++)
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    // Resharper says do this to avoid "Access to modified closure"
                    var i1 = i;

                    Application.Current.Dispatcher.InvokeAsync(() =>
                        {
                            Records.Add(new Model
                                {
                                    Name = NamesList[i1],
                                    Number = i1
                                });

                            Status = "cur: " +
                                        i1.ToString(
                                            CultureInfo.InvariantCulture);
                        });

                    // Artificial delay so we can see what's going on
                    await Task.Delay(200);
                }

                Records[0].Name = "Yes!";
            }, cancellationToken);

        return true;
    }
    catch (Exception)
    {
        return false;
    }
}

public async Task<bool> PopulateListStartNew(CancellationToken cancellationToken, TaskScheduler taskScheduler)
{
    try
    {
        var task = await Task.Factory.StartNew(async () =>
            {
                // Clear the records out first, if any
                Records.Clear();


                for (var i = 0; i < 10; i++)
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    Records.Add(new Model
                        {
                            Name = NamesList[i],
                            Number = i
                        });

                    Status = "cur: " +
                                i.ToString(
                                    CultureInfo.InvariantCulture);


                    // Artificial delay so we can see what's going on
                    await Task.Delay(200);
                }

                Records[0].Name = "Yes!";
            }, cancellationToken, TaskCreationOptions.None, taskScheduler);

        // Had to add this
        await task.ContinueWith(_ => true);
    }
    catch (Exception)
    {
        return false;
    }

    // Had to move this out of try block
    return true;
}
4

2 回答 2

5

您在问题中发布的链接有答案：Task.Run理解并解开async Task代表，而StartNew返回 aTask<Task>相反，您必须通过调用Unwrap或执行 double-来解开自己await。

但是，我建议您完全重写代码，如下所示。笔记：

  • 不要使用Dispatcher. async正确编写的代码不需要它。
  • 将所有后台工作方法和异步操作视为 UI 线程的“服务”。因此，您的方法将根据需要定期返回 UI 上下文。

像这样：

public async Task<bool> PopulateListTaskRunAsync(CancellationToken cancellationToken)
{
  try
  {
    // Clear the records out first, if any
    Records.Clear();

    for (var i = 0; i < 10; i++)
    {
      cancellationToken.ThrowIfCancellationRequested();

      Records.Add(new Model
      {
        Name = NamesList[i],
        Number = i
      });

      Status = "cur: " + i.ToString(CultureInfo.InvariantCulture);

      // Artificial delay so we can see what's going on
      await Task.Delay(200);
    }

    Records[0].Name = "Yes!";
    return true;
  }
  catch (Exception)
  {
    return false;
  }
}
于 2013-06-20T03:27:36.847 回答
1

我对所有这些管道都不太满意，但我会尽力回答。

首先为什么你的第二个代码不起作用：

  • 您给StartNew一个类似于Func<Task>的异步委托，因此StartNew将返回一个Task<Task>并且您等待外部任务立即结束，因为它包括返回内部任务（不太确定）

  • 然后你等待内部任务的继续，执行的内部线程，你打算做什么；但我想如果你以这种方式直接等待内部任务本身，它应该是一样的：

    await await Task.Factory.StartNew(async ...

为什么您的第一个代码有效：

  • 根据MSDN文档 Task.Run直接返回一个Task对象，内部任务我猜

  • 所以你直接等待内部任务，而不是中间任务，所以它按预期工作

至少这是我的理解并记住我还没有玩过所有这些东西（没有 VS 2012）。:)

于 2013-06-20T00:21:49.390 回答