I have this construct in my main(), which creates
var tasks = new List<Task>(); var t = Task.Factory.StartNew( async () => { Foo.Fim(); await Foo.DoBar(); }); //DoBar not completed t.Wait(); //Foo.Fim() done, Foo.DoBar should be but isn't However, when I .Wait for t, it won't wait for the call to DoBar() to complete. How do I get it to actually wait?
It's discouraged to use Task.Factory.StartNew with async-await, you should be using Task.Run instead:
var t = Task.Run( async () => { Foo.Fim(); await Foo.DoBar(); }); The Task.Factory.StartNew api was built before the Task-based asynchronous pattern (TAP) and async-await. It will return Task<Task> because you are starting a task with a lambda expression which happens to be async and so returns a task. Unwrap will extract the inner task, but Task.Run will implicitly do that for you.
For a deeper comparison, there's always a relevant Stephen Toub article: Task.Run vs Task.Factory.StartNew
Task.Run. This additionally answers my confusion about why Task.Run is different with the async/awaits. Thanks.
"Task.Factory.StartNew(someAction, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);" as the article says. This clearly needs further reading when your using async/await rather than simple actions.
It seems like I get desired functionality by Unwrap()ing the task. I'm not quite sure I get the reasoning behind this, but I suppose it works.
var t = Task.Factory.StartNew( async () => { Foo.Fim(); await Foo.DoBar(); }).Unwrap(); edit: I've looked for ddescription of Unwrap(): Creates a proxy Task that represents the asynchronous operation of a Task<Task<T>> I thought this was traditionally what the task did, but if I need to call unwrap I suppose that's fine.
Task.Run() seems the way to go.
Foo.Dim() inside the task, in the first place? I.e., maybe you can simply do this: Foo.Fimm(); Foo.DoBar().Wait(); - without creating a new Task via Run or StartNew.
Unwrap() just ends up throwing a Start may not be called on a promise-style task. exception :/I faced similar issue recently and figured out that all you need to do is have DoBar() return some value and use .Result instead of wait.
var g = Task.Run(() => func(arg)); var val = g.Result; This will wait for func to return its output and assign it to val.
Task.StartNew(async() => ...)) and which explains what's going on