Exécuter la méthode "async" sur un thread d'arrière-plan

Je suis en train de lancer un "async" méthode à partir d'une méthode ordinaire:

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
}

L'exception renvoyée est:

De démarrage ne peut pas être appelé sur une poursuite de la tâche.

Ce que ça veut dire, de toute façon? Comment puis-je exécuter simplement ma méthode asynchrone sur un thread d'arrière-plan, envoyer le résultat dans le thread de l'INTERFACE utilisateur?

Modifier

Aussi essayé Task.Waitmais l'attente n'en finit pas:

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();
}

source d'informationauteur McGarnagle

  1. 30

    Pour fixer votre exemple particulier:

    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());
}

    Cela va fonctionner, mais c'est de la vieille école.

    Le moyen moderne de faire quelque chose sur un thread d'arrière-plan et de l'expédition de retour à la thread de l'INTERFACE utilisateur est d'utiliser Task.Run()asyncet await:

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

    Task.Run va commencer quelque chose dans un thread du pool. Lorsque vous await quelque chose, automatiquement, il revient sur le contexte d'exécution qui a commencé. Dans ce cas, votre thread de l'INTERFACE utilisateur.

    Vous devriez généralement de ne jamais avoir à appeler Start(). Préférez async méthodes, Task.Runet Task.Factory.StartNewqui tous démarrer les tâches automatiquement. Les Continuations créé avec await ou ContinueWith sont également démarré automatiquement lorsque leurs parents se termine.

  2. 1

    AVERTISSEMENT sur l'utilisation FromCurrentSynchronizationContext:

    Ok, Cory sait comment me faire réécrire réponse:).

    De sorte que le principal coupable est en fait le FromCurrentSynchronizationContext!
    Tout moment StartNew ou ContinueWith fonctionne sur ce type de planificateur, il fonctionne sur le Thread de l'INTERFACE utilisateur. On peut le penser:

    OK, nous allons commencer les opérations suivantes sur l'INTERFACE utilisateur, le changement de certains contrôles, la réapparition de certaines opérations. Mais à partir de maintenant TaskScheduler.Courant n'est pas nul et si aucun contrôle a certains événements, qui se reproduisent certains StartNew, s'attendant à être en cours d'exécution sur ThreadPool, puis à partir de là, il va mal. L'INTERFACE utilisateur de l'aps sont généralement complexes, le malaise de maintenir la certitude, que rien ne va en appeler une autre StartNew l'opération, simple exemple ici:

    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! - OK
    2. TestA.Commencer:ThreadUI! - OK
    3. TestA.Fin:ThreadUI! - OK
    4. Form1:ThreadUI! - OK
    5. TestA.StartNew:ThreadPool - OK
    6. TestA.ContinuWith:ThreadUI! - OK
    7. TestB.Commencer:ThreadUI! - OK
    8. TestB.Fin:ThreadUI! - OK
    9. TestB.StartNew prévu de pool de threads:ThreadUI! - POURRAIT ÊTRE INATTENDU!
    10. TestB.ContinueWith1 devrait être de pool de threads:ThreadUI! - POURRAIT ÊTRE INATTENDU!
    11. TestB.ContinueWith2:ThreadUI! - OK

    Veuillez notez que les tâches retourné par:

    1. méthode async,
    2. Tâche.Fatory.StartNew,
    3. Tâche.Exécuter,

    ne peut pas être démarré! Ils sont déjà bien chaudes tâches...