What is a Task in .NET? Is a Task the same as a thread?

1. What's inside a Task

Conceptually:

Task
 ├─ m_stateFlags        (status bits: started, completed, faulted, canceled, ...)
 ├─ m_continuationObject (null | single continuation | list of continuations)
 ├─ m_action / m_stateObject (delegate tasks only)
 ├─ m_contingentProperties (lazily: exception holder, cancellation registration, parent, ...)
 └─ (Task<T>) m_result

The common case is lean: a completed async method with no exception doesn't allocate the contingent properties. Completing a task atomically sets the state and then runs or schedules continuations.

2. How a promise task completes

var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
socket.OnMessage += msg => tcs.TrySetResult(msg);   // completed by an event, no thread waiting
string first = await tcs.Task;

RunContinuationsAsynchronously makes the awaiting code run on the pool instead of synchronously inside the TrySetResult call, which avoids surprising re-entrancy and deadlocks in the completing code.

3. Hot tasks and concurrency

Task<int> a = GetAAsync();   // starts now
Task<int> b = GetBAsync();   // starts now
int[] r = await Task.WhenAll(a, b);   // observes both

await never starts anything; it only observes. Tasks returned by methods are already running. That's why the order of starting vs awaiting decides whether work is sequential or concurrent.

4. WhenAll exception semantics

• The returned task faults with all inner exceptions in its AggregateException.
• await Task.WhenAll(...) rethrows only the first; inspect the WhenAll task's Exception.InnerExceptions (or each task) to see all.
• It completes only when all tasks finish, even if one fails early; use cancellation or WhenEach/WhenAny if you want to stop early.

5. WhenEach (.NET 9+)

Task<Quote>[] quotes = providers.Select(p => p.GetQuoteAsync(ct)).ToArray();
await foreach (Task<Quote> done in Task.WhenEach(quotes))
{
    if (done.IsCompletedSuccessfully) Show(done.Result);   // safe: it's complete
}

This replaces the old while (tasks.Count > 0) { var t = await Task.WhenAny(tasks); tasks.Remove(t); } pattern, which was O(n²).

6. WaitAsync vs cancellation

task.WaitAsync(TimeSpan.FromSeconds(2)) stops waiting; the underlying operation keeps running. To actually stop the work, pass a CancellationToken into the operation itself.

7. Version notes

8. Try it yourself

1. Run the code example and compare sequential vs concurrent timings.
2. Print ThreadPool.ThreadCount during 1,000 concurrent Task.Delay(1000) calls: it stays small.
3. Make two of three tasks throw and inspect await vs the WhenAll task's Exception.InnerExceptions.
4. Replace a WhenAny loop with Task.WhenEach and print results in completion order.
5. Use Task.Factory.StartNew(async () => { await Task.Delay(1000); }) and observe it "completes" immediately; fix it with Task.Run or .Unwrap().
6. Create a TaskCompletionSource without RunContinuationsAsynchronously, complete it while holding a lock, and observe the continuation running inside the lock.

using System.Diagnostics;

var sw = Stopwatch.StartNew();
int a = await FetchAsync("orders", 300);
int b = await FetchAsync("stock", 400);
int c = await FetchAsync("prices", 200);
Console.WriteLine($"Sequential: {sw.ElapsedMilliseconds} ms"); // about 900

sw.Restart();
Task<int> orders = FetchAsync("orders", 300); // hot: already running
Task<int> stock = FetchAsync("stock", 400);
Task<int> prices = FetchAsync("prices", 200);
int[] all = await Task.WhenAll(orders, stock, prices);
Console.WriteLine($"Concurrent: {sw.ElapsedMilliseconds} ms, total {all.Sum()}"); // about 400

// A promise task with no thread behind it.
var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
_ = Task.Delay(100).ContinueWith(_ => tcs.SetResult("signalled"), TaskScheduler.Default);
Console.WriteLine(await tcs.Task);

static async Task<int> FetchAsync(string name, int ms)
{
    await Task.Delay(ms); // stands in for an HTTP call
    return ms;
}