在后台线程上运行“异步”方法

Question

我正在尝试从普通方法运行“异步”方法：

public string Prop
{
    get { return _prop; }
    set
    {
        _prop = value;
        RaisePropertyChanged();
    }
}

private async Task<string> GetSomething()
{
    return await new Task<string>( () => {
        Thread.Sleep(2000);
        return "hello world";
    });
}

public void Activate()
{
    GetSomething.ContinueWith(task => Prop = task.Result).Start();
    // ^ exception here
}

抛出的异常是：

不能在连续任务上调用 Start。

这到底是什么意思？我怎样才能简单地在后台线程上运行我的异步方法，将结果分派回 UI 线程？

编辑

也尝试过

Task.Wait

，但等待永远不会结束：

public void Activate()
{
    Task.Factory.StartNew<string>( () => {
        var task = GetSomething();
        task.Wait();

        // ^ stuck here

        return task.Result;
    }).ContinueWith(task => {
        Prop = task.Result;
    }, TaskScheduler.FromCurrentSynchronizationContext());
    GetSomething.ContinueWith(task => Prop = task.Result).Start();
}

Answer 1

要具体修复您的示例：

public void Activate()
{
    Task.Factory.StartNew(() =>
    {
        //executes in thread pool.
        return GetSomething(); // returns a Task.
    }) // returns a Task<Task>.
    .Unwrap() // "unwraps" the outer task, returning a proxy
              // for the inner one returned by GetSomething().
    .ContinueWith(task =>
    {
        // executes in UI thread.
        Prop = task.Result;
    }, TaskScheduler.FromCurrentSynchronizationContext());
}

这会起作用，但它是老派的。

在后台线程上运行某些内容并分派回 UI 线程的现代方法是使用

Task.Run()

、

async

和

await

:

async void Activate()
{
    Prop = await Task.Run(() => GetSomething());
}

Task.Run

将在线程池线程中启动某些内容。当您

await

某事时，它会自动返回启动它的执行上下文。在本例中，是您的 UI 线程。

您通常不需要打电话

Start()

。首选

async

方法、

Task.Run

和

Task.Factory.StartNew

——所有这些方法都会自动启动任务。使用

await

或

ContinueWith

创建的延续也会在其父级完成时自动启动。

Answer 2

有关使用 FromCurrentSynchronizationContext 的警告：

好吧，科里知道如何让我重写答案:)。

所以罪魁祸首实际上是FromCurrentSynchronizationContext！ 任何时候 StartNew 或 ContinueWith 在此类调度程序上运行时，它都会在 UI 线程上运行。有人可能会想：

好的，让我们开始UI上的后续操作，更改一些控件，生成一些操作。但从现在开始，TaskScheduler.Current 不为空，并且如果任何控件有一些事件，这些事件会产生一些期望在 ThreadPool 上运行的 StartNew，那么从那里开始就会出错。 UI aps 通常很复杂，难以保持确定性，没有什么会调用另一个 StartNew 操作，这里简单的例子：

public partial class Form1 : Form
{
    public static int Counter;
    public static int Cnt => Interlocked.Increment(ref Counter);
    private readonly TextBox _txt = new TextBox();
    public static void WriteTrace(string from) => Trace.WriteLine($"{Cnt}:{from}:{Thread.CurrentThread.Name ?? "ThreadPool"}");

    public Form1()
    {
        InitializeComponent();
        Thread.CurrentThread.Name = "ThreadUI!";

        //this seems to be so nice :)
        _txt.TextChanged += (sender, args) => { TestB(); };

        WriteTrace("Form1"); TestA(); WriteTrace("Form1");
    }
    private void TestA()
    {
        WriteTrace("TestA.Begin");
        Task.Factory.StartNew(() => WriteTrace("TestA.StartNew"))
        .ContinueWith(t =>
        {
            WriteTrace("TestA.ContinuWith");
            _txt.Text = @"TestA has completed!";
        }, TaskScheduler.FromCurrentSynchronizationContext());
        WriteTrace("TestA.End");
    }
    private void TestB()
    {
        WriteTrace("TestB.Begin");
        Task.Factory.StartNew(() => WriteTrace("TestB.StartNew - expected ThreadPool"))
        .ContinueWith(t => WriteTrace("TestB.ContinueWith1 should be ThreadPool"))
        .ContinueWith(t => WriteTrace("TestB.ContinueWith2"));
        WriteTrace("TestB.End");
    }
}

1. Form1：ThreadUI！ - 好的
2. TestA.Begin：ThreadUI！ - 好的
3. TestA.End：ThreadUI！ - 好的
4. Form1：ThreadUI！ - 好的
5. TestA.StartNew：线程池 - 确定
6. TestA.ContinuWith：ThreadUI！ - 好的
7. TestB.Begin：ThreadUI！ - 好的
8. TestB.End：ThreadUI！ - 好的
9. TestB.StartNew - 预期线程池：ThreadUI！ - 可能会出乎意料！
10. TestB.ContinueWith1 应该是 ThreadPool:ThreadUI！ - 可能会出乎意料！
11. TestB.ContinueWith2：ThreadUI！ - 好的

请注意，任务返回者：

1. 异步方法，
2. Task.Fatory.StartNew，
3. 任务.运行，

无法启动！它们已经是热门任务...

Answer 3

根据之前的答案，我使用了异步方法在后台运行，那么代码略有不同：

_ = Task.Run(async  ()  => await BWSMailLogic.CheckTaskStatus(task, user));

它将在后台运行 CheckTaskStatus。它将立即继续该过程。请务必在后台运行的方法中添加良好的异常处理。由于该过程不等待结果，因此您不需要遵循过程中的结果才有意义。