在后台线程上运行"async"方法

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不为null，如果任何控件有一些事件，这些事件产生了一些StartNew，期望在ThreadPool上运行，那么它就错了。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:线程UI！-好的
2. 测试A.Begin:线程UI！-好的
3. 测试A.End：线程UI！-好的
4. Form1:线程UI！-好的
5. TestA.StartNew:线程池-确定
6. TestA.ContinuWith:线程UI！-好的
7. 测试B.Begin:线程UI！-好的
8. 测试B.End：线程UI！-好的
9. TestB.StartNew-预期ThreadPool:ThreadUI！-可能出乎意料
10. TestB.ContinueWith1应为ThreadPool:ThreadUI！-可能出乎意料
11. 测试B:ContinueWith2:线程UI！-好的

请注意，任务返回者：

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

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