24

Might be a trivial question, but it might help me in basic understanding.

Is there any important difference between two following implementations?

  1. Task.Factory.StartNew: 

    public Task<string> ReadAllTextAsync(string path) { return Task.Factory.StartNew(() => File.ReadAllText(path)); }

  2. Async method on StreamReader:

    public async Task<string> ReadAllTextAsync(string path) { using (var stream = File.OpenRead(path)) using (var reader = new StreamReader(stream)) { return await reader.ReadToEndAsync(); } }
Improve this question

1 Answer 1

Reset to default
26

Yes, there's a crucial difference: the Task.Factory.StartNew is not preserving the synchronization context whereas when using async/await this context is preserved. For example in an ASP.NET application this means that if you use Task.Factory.StartNew the HttpContext might not be accessible inside the task whereas if you use async/await it will be available.

There's also another important difference with the example you provided. In the first case you are using a blocking API: File.ReadAllText(path) whereas in the second case you are using an I/O Completion port with a true asynchronous I/O operation. This means that in the first case you are jeopardizing the thread on which this task executes during the entire time this task is executing whereas in the second case this thread is free thanks to an I/O Completion Port.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

@dtb, we cannot really talk about a ThreadPool when dealing with Tasks. The first example is blocking the thread in which the task executes, whereas in the second example it does not. I have updated my answer to include this information.
Thank you, that clarifies it (especially the second point, I had a suspicion there is some inefficiency in IO).
@DarinDimitrov Isn't the difference in synchronization context largely a factor of the defaults used for Task.Factory.StartNew and await? Manipulation of the TaskScheduler used for StartNew and ConfigureAwait on awaitables can lead them to use the same context if I'm not mistaken. In that case there are still some underlying differences, but they're a bit more subtle.
After examining the issue in more depth, I am further convinced that this answer could be misleading. It does point out the differences in implementation 1 and 2, but these are not fundamental differences between the async/await pattern and use of Task.Factory.StartNew. It would be easy for readers to misconstrue this answer as one explaining fundamental differences between Tasks and asyncs (especially given the question title). @DarinDimitrov - I suggest you edit to make this distinction clear. I would make the edit myself, but with your higher rep, would appreciate your blessing.
@Snixtor, and what are the fundamental differences according to you? Feel free to edit my answer. I will revert it back if I don't agree with your edits.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.