Creare un'attività Cold Awaitable

Question

Ho un metodo asincrono dopo il completamento del quale desidero eseguire un altro metodo. Funziona bene se chiamo semplicemente il metodo e aggiungo .ContinueWith()

Tuttavia, ho un nuovo requisito che è quello di avviare l'attività solo se sono in grado di aggiungerlo a un dizionario concorrente.

desidero costruire il compito, tentare di aggiungere e poi avviare l'attività

Tuttavia, sembra che Task.Start() completa immediatamente l'attività che causa l'azione continuerà a funzionare e le eventuali attese a .. non aspettare.

qualcuno può spiegare perché questo accade e il modo corretto per raggiungere il mio obiettivo?

namespace UnitTestProject2 
{ 
    [TestClass] 
    public class taskProblem 
    { 
     [TestMethod] 
     public void Test() 
     { 
      CancellationTokenSource cancel = new CancellationTokenSource(); 
      ConcurrentDictionary<Guid, Task> tasks = new ConcurrentDictionary<Guid,Task>(); 
      Guid id = Guid.NewGuid(); 
      Task t = new Task(async() => await Get(), cancel.Token); 
      t.ContinueWith(Complete); 
      if (tasks.TryAdd(id, t)) 
      { 
       t.Start(); 
      } 
      else 
      { 
       //another thread is stopping stuff dont start new tasks 
      } 

      t.Wait(); //expected to wait for the get function to complete 
      Console.WriteLine("end test"); 
     } 

     public async Task Get() 
     { 
      Console.WriteLine("start task"); 
      await Task.Delay(10000); 
      Console.WriteLine("end task"); 
     } 

     public void Complete(Task t) 
     { 
      Console.WriteLine("Complete"); 
     } 
    } 
} 

uscita:

start task 
end test 
Complete 

risultato atteso:

start task 
end task 
Complete 
end test 

Aggiornamento: Sembra non v'è alcun modo per creare una nuova attività, che non si avvia immediatamente o completa subito su Task.Start?

Answer 1

Il delegato è vuoto asincrono. i metodi void asincroni sono fuoco e dimenticano.

Vedi primo punto di sintesi di modelli e anti-pattern: http://rarcher.azurewebsites.net/Post/PostContent/31

Forse si può fare qualcosa di simile:

[TestFixture] 
public class FIXTURENAMETests { 
    [Test] 
    public async Task NAME() { 
    var tcs = new TaskCompletionSource<bool>(); 
    Task t = LongRunningStuff(tcs); 

    if (CanInsertInDictionary(t)) { 
     tcs.SetResult(true); 
    } else { 
     tcs.SetException(new Exception()); 
    } 

    Trace.WriteLine("waiting for end"); 

    try { 
     await t; 
    } 
    catch (Exception exception) { 
     Trace.WriteLine(exception); 
    } 

    Trace.WriteLine("end all"); 
    } 

    private bool CanInsertInDictionary(Task task) { 
    return true; 
    } 

    private async Task LongRunningStuff(TaskCompletionSource<bool> tcs) { 
    Trace.WriteLine("start"); 
    try { 
     await tcs.Task; 
    } 
    catch (Exception) { 
     return; 
    } 
    Trace.WriteLine("do long running stuff"); 
    await Task.Delay(10000); 
    Trace.WriteLine("end"); 
    } 
} 

Answer 2

In primo luogo, ContinueWith restituirà un nuovo Task, si vuole aspettare fino a il metodo Complete è completo ma è in attesa della prima attività t.

Quindi, all'uscita Complete prima end test, bisogna aspettare il secondo compito:

Task t = new Task(async() => await Get(), cancel.Token); 

// NOTE: t2 is a new Task returned from ContinueWith 
Task t2 = t.ContinueWith(Complete); 

if (tasks.TryAdd(id, t)) 
{ 
    t.Start(); 
} 
else 
{ 
} 

// NOTE: Waiting on t2, NOT t 
t2.Wait(); 

Console.WriteLine("end test"); 

Ora l'uscita sarà:

start task 
Complete 
end test 
end task 

Ok, questo non è ancora il risultato previsto . end task deve essere stampato prima dello Complete. Questo perché l'azione asincrona non è attendibile: How to await on async delegate

Non so se ho compreso correttamente le tue esigenze. Se sono io, potrei fare in questo modo:

aggiungere una nuova classe di supporto:

public class TaskEntry 
{ 
    public Task Task { get; set; } 
} 

quindi modificare il codice per:

Guid id = Guid.NewGuid(); 

Task task = null; 
var entry = new TaskEntry(); 
if (tasks.TryAdd(id, entry)) 
{ 
    entry.Task = Get(); 

    // Notice this line of code: 
    task = entry.Task.ContinueWith(Complete); 
} 

if (task != null) 
{ 
    task.Wait(); 
} 

Console.WriteLine("end test"); 

Qui Suppongo che il TaskEntry non ci sarà modificato da altri thread.