ValueTask C# Double-Await Bug — Duplicate Payments

using System;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;

public class AllocationComparison
{
    private static readonly string? _cachedGreeting = "Hello, World!";

    public static Task<string> GetGreetingWithTask(bool forceAsync)
    {
        if (!forceAsync && _cachedGreeting is not null)
        {
            return Task.FromResult(_cachedGreeting);
        }
        return SimulateSlowDatabaseCallAsync();
    }

    public static ValueTask<string> GetGreetingWithValueTask(bool forceAsync)
    {
        if (!forceAsync && _cachedGreeting is not null)
        {
            return new ValueTask<string>(_cachedGreeting);
        }
        return new ValueTask<string>(SimulateSlowDatabaseCallAsync());
    }

    private static async Task<string> SimulateSlowDatabaseCallAsync()
    {
        await Task.Delay(50);
        return "Hello from database!";
    }

    public static async Task Main(string[] args)
    {
        int iterations = 100_000;
        long gcBefore, gcAfter;

        GC.Collect();
        gcBefore = GC.CollectionCount(0);

        for (int i = 0; i < iterations; i++)
        {
            string result = await GetGreetingWithTask(forceAsync: false);
            _ = result;
        }

        gcAfter = GC.CollectionCount(0);
        Console.WriteLine($"Task path — Gen0 GC collections: {gcAfter - gcBefore}");

        GC.Collect();
        gcBefore = GC.CollectionCount(0);

        for (int i = 0; i < iterations; i++)
        {
            string result = await GetGreetingWithValueTask(forceAsync: false);
            _ = result;
        }

        gcAfter = GC.CollectionCount(0);
        Console.WriteLine($"ValueTask path — Gen0 GC collections: {gcAfter - gcBefore}");
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Sources;
using System.Collections.Generic;

public class PooledValueTaskSource : IValueTaskSource<int>
{
    private short _currentToken;
    private int _result;
    private bool _isCompleted;
    private Action<object?>? _continuation;
    private object? _continuationState;

    public int GetResult(short token)
    {
        if (token != _currentToken)
            throw new InvalidOperationException(
                "ValueTask was awaited after its underlying source was recycled. " +
                "Never await the same ValueTask more than once.");

        if (!_isCompleted)
            throw new InvalidOperationException("Result not yet available.");

        int capturedResult = _result;
        _currentToken++;
        _isCompleted = false;
        _continuation = null;
        Console.WriteLine($"[Pool] Source recycled. New token is {_currentToken}.");

        return capturedResult;
    }

    public ValueTaskSourceStatus GetStatus(short token)
    {
        if (token != _currentToken)
            throw new InvalidOperationException("Stale token — source has been recycled.");
        return _isCompleted ? ValueTaskSourceStatus.Succeeded : ValueTaskSourceStatus.Pending;
    }

    public void OnCompleted(
        Action<object?> continuation,
        object? state,
        short token,
        ValueTaskSourceOnCompletedFlags flags)
    {
        _continuation = continuation;
        _continuationState = state;
    }

    public void SignalCompletion(int result)
    {
        _result = result;
        _isCompleted = true;
        Console.WriteLine($"[Source] Signalled completion with result: {result}");
        _continuation?.Invoke(_continuationState);
    }

    public ValueTask<int> AsValueTask() => new ValueTask<int>(this, _currentToken);
}

public class IValueTaskSourceDemo
{
    public static async Task Main(string[] args)
    {
        var source = new PooledValueTaskSource();
        var backgroundWork = Task.Run(async () =>
        {
            await Task.Delay(100);
            source.SignalCompletion(result: 42);
        });

        ValueTask<int> valueTask = source.AsValueTask();
        Console.WriteLine("[Main] Awaiting ValueTask...");
        int answer = await valueTask;
        Console.WriteLine($"[Main] Result: {answer}");

        try
        {
            int staleAnswer = await valueTask;
            Console.WriteLine($"[Main] Stale result: {staleAnswer}");
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"[Main] Caught expected error: {ex.Message}");
        }

        await backgroundWork;
    }
}

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Net.Http;

public class HttpResponseCache
{
    private readonly HttpClient _httpClient;
    private readonly ConcurrentDictionary<string, string> _cache = new();

    public HttpResponseCache(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public ValueTask<string> GetContentAsync(string url)
    {
        if (_cache.TryGetValue(url, out string? cachedContent))
        {
            Console.WriteLine($"[Cache] HIT for {url} — no allocation, no await suspension");
            return new ValueTask<string>(cachedContent);
        }

        Console.WriteLine($"[Cache] MISS for {url} — initiating HTTP request");
        return new ValueTask<string>(FetchAndCacheAsync(url));
    }

    private async Task<string> FetchAndCacheAsync(string url)
    {
        string content = await _httpClient.GetStringAsync(url);
        _cache[url] = content;
        Console.WriteLine($"[Cache] Stored {content.Length} chars for {url}");
        return content;
    }
}

public class FanOutExample
{
    public static async Task DemonstrateWhyTaskWinsForFanOut(HttpResponseCache cache)
    {
        string url = "https://example.com";
        Task<string> sharedTask = cache.GetContentAsync(url).AsTask();

        string firstResult = await sharedTask;
        string secondResult = await sharedTask;
        Console.WriteLine($"Fan-out result 1: {firstResult.Substring(0, Math.Min(30, firstResult.Length))}...");
        Console.WriteLine($"Fan-out result 2 (same task): {secondResult.Substring(0, Math.Min(30, secondResult.Length))}...");
    }

    public static async Task Main(string[] args)
    {
        using var httpClient = new HttpClient();
        var cache = new HttpResponseCache(httpClient);
        string content1 = await cache.GetContentAsync("https://example.com");
        Console.WriteLine($"First call — got {content1.Length} chars\n");
        string content2 = await cache.GetContentAsync("https://example.com");
        Console.WriteLine($"Second call — got {content2.Length} chars\n");
        await DemonstrateWhyTaskWinsForFanOut(cache);
    }
}

// Install BenchmarkDotNet: dotnet add package BenchmarkDotNet
// Run with: dotnet run -c Release
// The [MemoryDiagnoser] attribute is what shows you allocations per operation.

using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[RankColumn]
public class ValueTaskBenchmarks
{
    private const int CachedValue = 99;

    [Benchmark(Baseline = true)]
    public async Task<int> GetWithTask()
    {
        return await Task.FromResult(CachedValue);
    }

    [Benchmark]
    public async ValueTask<int> GetWithValueTask()
    {
        return await new ValueTask<int>(CachedValue);
    }

    [Benchmark]
    [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<int>))]
    public async ValueTask<int> GetWithPooledValueTask()
    {
        return await new ValueTask<int>(CachedValue);
    }

    [Benchmark]
    public async ValueTask<int> GetWithValueTaskActuallyAsync()
    {
        await Task.Yield();
        return CachedValue;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<ValueTaskBenchmarks>();
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Sources;

public class AsyncLocalBugDemo
{
    private static readonly AsyncLocal<string> _correlationId = new();

    public static async Task Main()
    {
        // Simulate a pooled source
        var source = new SimplePooledValueTaskSource();

        // Task 1 sets correlation ID
        var task1 = Task.Run(async () =>
        {
            _correlationId.Value = "req-001";
            Console.WriteLine($"Task1: Before await, CorrelationId = {_correlationId.Value}");
            await source.AsValueTask();
            Console.WriteLine($"Task1: After await, CorrelationId = {_correlationId.Value}");
        });

        // Task 2 sets a different correlation ID
        var task2 = Task.Run(async () =>
        {
            await Task.Delay(50); // ensure task1 starts first
            _correlationId.Value = "req-002";
            Console.WriteLine($"Task2: Before await, CorrelationId = {_correlationId.Value}");
            await source.AsValueTask();
            Console.WriteLine($"Task2: After await, CorrelationId = {_correlationId.Value}");
        });

        await Task.WhenAll(task1, task2);
    }
}

// Minimal IValueTaskSource that recycles after one use
public class SimplePooledValueTaskSource : IValueTaskSource<int>
{
    private short _token;
    private int _result;
    private bool _completed;
    private Action<object?>? _continuation;
    private object? _state;

    public int GetResult(short token)
    {
        if (token != _token) throw new InvalidOperationException("Stale");
        _token++;
        return _result;
    }

    public ValueTaskSourceStatus GetStatus(short token) => _completed ? ValueTaskSourceStatus.Succeeded : ValueTaskSourceStatus.Pending;

    public void OnCompleted(Action<object?> cont, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
    {
        _continuation = cont;
        _state = state;
    }

    public void SignalCompletion(int result)
    {
        _result = result;
        _completed = true;
        _continuation?.Invoke(_state);
    }

    public ValueTask<int> AsValueTask() => new(this, _token);
}

/*
Sample output (non-deterministic but illustrates the problem):
Task1: Before await, CorrelationId = req-001
Task2: Before await, CorrelationId = req-002
Task1: After await, CorrelationId = req-002  ← Wrong! The correlation leaked from task2
Task2: After await, CorrelationId = req-002
*/