Difference Between Task and Task<T> in C

In C# asynchronous programming, Task and Task<T> are core constructs used to manage asynchronous operations, with the primary difference being whether or not the operation returns a value. A non-generic Task represents an asynchronous operation that executes and completes without returning a result, functioning similarly to an asynchronous void. In contrast, a generic Task<T> represents an asynchronous operation that returns a specific data type T upon completion, serving as the asynchronous equivalent of a non-void method.

What is a Task?

The Task class in the System.Threading.Tasks namespace represents an ongoing or completed unit of work. It is designed for asynchronous operations that perform actions without needing to pass data back to the caller.

Common use cases for Task include:

Writing data to a file on disk.
Sending a notification or message over a network.
Updating a database record where no output is required.

When using async and await, a method returning Task uses the return; statement or simply reaches the end of the method block without an explicit return:

public async Task SaveLogAsync(string message)
{
    await File.AppendAllTextAsync("log.txt", message);
}

What is a Task<T>?

The Task<T> class (often documented as Task<TResult>) inherits directly from Task. It represents an asynchronous operation that produces a value of type T when it finishes execution.

Common use cases for Task<T> include:

Querying a database for a record or a list of items.
Making an HTTP GET request to fetch JSON from a web API.
Calculating a computationally expensive result in the background.

When calling a method that returns Task<T>, awaiting it yields the underlying type T:

public async Task<string> FetchUserDataAsync(int userId)
{
    using var client = new HttpClient();
    string response = await client.GetStringAsync($"https://api.example.com/users/{userId}");
    return response;
}

// Consuming Task<T>
string userData = await FetchUserDataAsync(1);

Key Differences

Feature	`Task`	`Task<T>`
Return Value	None (acts like `void`)	Returns a value of type `T`
Inheritance	Base class	Inherits from `Task`
Awaiting Behavior	`await task;` yields no value	`T result = await taskOfT;` yields `T`
Synchronous Access	Blocks until completion (`task.Wait()`)	Blocks until completion and provides value (`task.Result`)
Method Signature	`public async Task DoWorkAsync()`	`public async Task<int> CalculateAsync()`

Choosing Between Task and Task<T>

Use Task when your asynchronous operation is purely for side effects—such as logging, updating state, or signaling events—where the caller only needs to know whether the operation succeeded, faulted, or was canceled. Use Task<T> whenever the caller requires the resulting data produced by the asynchronous operation to continue execution.