DEV Community

Mariem Moalla
Mariem Moalla

Posted on

Why ValueTask Can Save You from Async Overhead

#csharp #performance #dotnet

Asynchronous programming in C# is built on top of the Task and async/await model. For most scenarios, using Task is perfectly fine. But if you’re writing high-performance code, you’ve probably heard about ValueTask.

So, when should you use ValueTask instead of Task? Let’s break it down.

This is highly related to memory allocation so lets always try to see it from this perspective.

What is Task?

Tasks represent a promise of an operation that will eventually complete.It encapsulate the operation that can be executed independently on a different thread from the one that initialized it.
Let’s understand how tasks works with allocation.

Case 1 : Task Synchronous Completion

If your method completes synchronously (returns immediately without awaiting anything), the compiler/runtime still has to return a Task object.

(Usually, it uses a cached instance like Task.FromResult(value))

Note: This still creates or reuses a heap-allocated Task object.

public Task<int> GetNumberTask(bool cached)
{
    if (cached)
        return Task.FromResult(42); // allocation (cached instance but still a heap object)
    return DoRealWorkAsync();
}
Enter fullscreen mode Exit fullscreen mode

So Even if the value is already known (42), you pay the allocation cost for a Task object. even though int is value type.

And even if the result is already known immediately, the runtime must return a Task instance.

Case 2 : Task Asynchronous Completion

When the method awaits something:

The compiler generates an async struct that tracks the execution.
An it is boxed and tied to a an object to represent the ongoing work.
A new heap-allocated Task is created for the async result.

public async Task<int> GetNumberTaskAsync() 
{     
await Task.Delay(100);  // async suspension point     
return 42; 
}
Enter fullscreen mode Exit fullscreen mode

=> Async completion always involves allocations. synchronous may not.

What is ValueTask?

This is where ValueTask saves the day.Introduced in .NET Core 2.0 to reduce allocation overhead.A struct is designed to optimize asynchronous operations.

Unlike Tasks, Value tasks is a value type meaning we can avoid heap allocation when operation complete synchronously

Case 1 : Synchronous Completion

If you already know the result, the value is stored directly in the ValueTask struct.
No heap allocation occurs.

public ValueTask<int> GetNumberValueTaskSync()
{
    return new ValueTask<int>(42); // Value stored inline, no heap
}
Enter fullscreen mode Exit fullscreen mode

Case 2 : Asynchronous Completion:

If the method actually awaits something:

ValueTask internally wraps a Task.
That means you still get heap allocations, just like with Task.

public async ValueTask<int> GetNumberValueTaskAsync()
{
    await Task.Delay(100);   // async suspension point
    return 42;
}
Enter fullscreen mode Exit fullscreen mode

Here the benchmarking results can show clearly the difference between using ValueTask and Task in Synchronous completion.

Why this really matter as a .NET developper?

Understanding the difference between Task and ValueTask is crucial when writing high-performance asynchronous code in C#.

  • Task is simple and reliable, but even for synchronous completions, it may incur heap allocations. This overhead is usually negligible, but in tight loops or performance-critical paths, it can add up.
  • ValueTask shines in scenarios where the result is often already available synchronously. Since it’s a struct, it can store the result inline and avoid heap allocations, reducing GC pressure.

However, when an operation truly requires asynchronous execution, ValueTask internally wraps a Task anyway, so the allocation difference disappears.

By carefully choosing between Task and ValueTask, you can write cleaner, faster, and more memory-efficient async code especially in performance-critical applications.

Top comments (0)