Hello, I am Laszlo

Task over ValueTask<>

11/09/2025 | 5 minutes to read

I recently ran into some code that extensively used ValueTask types along with Task. I became curious if it is a good idea to mix async ValueTask<>s and Tasks. Moreover, .NET allows decorating methods returning ValueTask<> types with [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] that adds pooling behavior, which reduces allocations.

There are many ways to invoke async methods from another async method. The invoked async method can return a Task, ValueTask<>, or a pooled ValueTask<>; the calling method can also return any of these response types, and be a sync or async method. In this post, I create combinations of these methods to measure their performance footprint. The inner method may complete synchronously, asynchronously, or with a probability set between 0..1, where 1 means synchronous completion.

In this blog post, 'sync' completion refers to returning the result of an underlying async method without awaiting it, or without .Result / .GetAwaiter().GetResult() calls. It does not refer to the 'sync-over-async' anti-pattern.

I used BenchmarkDotNet to measure the performance and allocations of these method combinations. Please note that the allocations show 'non-round' numbers due to BenchmarkDotNet's aggregation when the probability falls between 0 and 1 exclusively. Async completions invoke Task.Yield(); - which yields execution of the current task, allowing other tasks to execute. While there should be no other tasks running in the benchmark, the Mean performance results include a non-trivial waiting duration, that is for the task continuation to execute.

The tables below show a guidance to choose certain designs, however, they must not be taken for granted. Actual allocations and performance must be measured in the production environment of production codebase, that reflects the real probabilty of sync/async completions.

Not all combinations are applicable in all situations. For example, it is intriguing to make the method at the callsite sync (ie. it returns the invoked method result without awaiting it), this might not be possible in all cases.

These benchmarks apply to .NET 10 Preview 7, at the time of writing the .NET team is working on a runtime implementation of these async concepts, where these results will likely not be applicable.

Measurement Results

Inner method returns Task:

Inner method returns ValueTask<>:

Inner method returns Pooled ValueTask<>:

Outer method returns ValueTask inner method returns Pooled ValueTask<>:

Analysis

• Being synchronous provides the best performance.

• Sync outer methods (not sync-over-async) reduce allocations

• Inner methods completing synchronously typically avoid allocations altogether

• When the inner method returns ValueTask<> and the outer method is sync, the return type (Task or ValueTask<>) doesn't impact performance

• For asynchronous completion with async outer methods:

  • ValueTask<> allocates 8 bytes (1 reference) more than Task

  • Async Task shows slightly better Mean execution performance

• Inner Pooled ValueTask<> completely eliminates allocations when the outer method also avoids allocations by:

  • Completing synchronously and returning ValueTask<>

• Async ValueTask<> with an inner method of Pooled ValueTask<> is the slowest overall solution; using an async Task appears to be a better choice

• Async case when converts a ValueTask<> to ValueTask the performance more-or-less matches the non-coverting one with slightly less allocations

Conclusion

The data highlights the trade-offs between performance, allocations, and code complexity when choosing between Task, ValueTask<>, and Pooled ValueTask<>. There is no one-size-fits-all solution, and the optimal choice depends on the specific requirements of the application.

Source Code Reference

[SimpleJob, MemoryDiagnoser]
public class Benchmarks
{
    [Params(0, 0.7, 1)]
    public double Probability { get; set; }

    [Benchmark]
    public async Task<bool> AsyncTaskOverValueTask() => await GetValue();

    [Benchmark]
    public Task<bool> TaskOverValueTask() => GetValue().AsTask();

    [Benchmark]
    public Task<bool> TaskOverTask() => GetTaskValue();

    [Benchmark]
    public async Task<bool> AsyncTaskOverTask() => await GetTaskValue();

    [Benchmark]
    public async ValueTask<bool> AsyncValueTaskOverTask() => await GetTaskValue();

    [Benchmark]
    public async ValueTask<bool> AsyncValueTaskOverValueTask() => await GetValue();

    [Benchmark]
    public async Task<bool> AsyncTaskOverPooledValueTask() => await GetValuePooled();

    [Benchmark]
    public Task<bool> TaskOverPooledValueTask() => GetValuePooled().AsTask();

    [Benchmark]
    public async ValueTask<bool> AsyncValueTaskOverPooledValueTask() => await GetValuePooled();

    [Benchmark]
    public ValueTask<bool> ValueTaskOverPooledValueTask() => GetValuePooled();

    [Benchmark]
    public ValueTask<bool> ValueTaskOverValueTask() => GetValue();

    [Benchmark]
    public async ValueTask AsyncNgValueTaskOverValueTask() => await GetValue();

    [Benchmark]
    public async ValueTask AsyncNgValueTaskOverPooledValueTask() => await GetValuePooled();

    [AsyncMethodBuilder(typeof(PoolingAsyncValueTask<>MethodBuilder<>))]
    public async ValueTask<bool> GetValuePooled()
    {
        if (Random.Shared.NextDouble() > Probability)
            await Task.Yield();
        return true;
    }

    public async ValueTask<bool> GetValue()
    {
        if (Random.Shared.NextDouble() > Probability)
            await Task.Yield();
        return true;
    }

    public async Task<bool> GetTaskValue()
    {
        if (Random.Shared.NextDouble() > Probability)
            await Task.Yield();
        return true;
    }
}