ValueTask<T> to ValueTask conversion

[epeshk]

This API was proposed before and already rejected.

But why it could not be implemented like this:

public static explicit operator ValueTask(ValueTask<TResult> task)
{
    if (valueTask.IsCompletedSuccessfully)
    {
        valueTask.GetAwaiter().GetResult();
        return default;
    }

    if (task._obj is not IValueTaskSource vts)
        return new ValueTask(task.AsTask());

    return new ValueTask(vts, task._token, task._continueOnCapturedContext);
}

It may be useful because:

• this conversion already exists for Task<T>/Task, and adding this to ValueTask improves user experience when moving to ValueTask/ValueTask<T>
• most runtime types implementing IValueTaskSource<T> also implements the non-generic IValueTaskSource: AsyncOperation<TResult>, PoolingAsyncValueTaskMethodBuilder<T>.StateMachineBox, AwaitableSocketAsyncEventArgs , PipeStream.PipeValueTaskSource, ManualResetValueTaskSource, so it is not useless method which will always fall back to the .AsTask() call with allocation.
• runtime already uses this conversion inside

If the only concerns are things like awaiting twice, or different .GetResult(token) implementations, this conversion may be added as hard to access method, like ref-returning methods in the CollectionsMarshal class.

[stephentoub]

But why it could not be implemented like this

We don't know for certain that the IValueTaskSource implementation is identical in purpose to the IValueTaskSource<T> implementation. Lots of implementations try to avoid allocation by implementing multiple interfaces for different purposes on the same object. You can, for example, implement IValueTaskSource<long> on an object to support a CountResultsAsync and an IValueTaskSource<double> on that same object to support a different ComputePiAsync, and so we can't assume that for example the OnCompleted they both share serves the same purpose. Similarly, assuming that an IValueTaskSource's implementation is substitutable for an IValueTaskSource<T>'s implementation could lead to bugs. We can do so for our own objects where we know they have the same behavior ("runtime already uses this conversion inside), but doing so generally isn't guaranteed.

[epeshk]

Thank you for an answer! I got it that in many cases a simple cast won't work.

But it is still looks solvable by introducing some proxy on top of IValueTaskSource<TResult>. Unfortunately, this wrapper couldn't be implemented safely in user code, as it requires access to the underlying ValueTask<TResult>._obj field.

internal class ValueTaskSourceProxy<TResult> : IValueTaskSource
{
  private IValueTaskSource<TResult> source;
  
  private ValueTaskSourceProxy() {}

  public static ValueTaskSourceProxy<TResult> For(IValueTaskSource<TResult> source)
  {
    // proxy objects are pooled like PoolingAsyncValueTaskMethodBuilder<TResult>.StateMachineBox<TStateMachine>
    var proxy = pool.TryRent() ?? new();
    proxy.source = source;
    return proxy;
  }

  public void GetResult(short token)
  {
    try
    {
      source.GetResult(token);
    }
    finally
    {
      source = default;
      pool.Return(this);
    }
  }

  public ValueTaskSourceStatus GetStatus(short token) =>
    source.GetStatus(token);

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

public static explicit operator ValueTask(ValueTask<TResult> task)
{
    if (valueTask.IsCompletedSuccessfully)
    {
        valueTask.GetAwaiter().GetResult();
        return default;
    }

    if (task._obj is not IValueTaskSource<TResult> vts)
        return new ValueTask(task.AsTask());

    return new ValueTask(ValueTaskSourceProxy<TResult>.For(vts), task._token, task._continueOnCapturedContext);
}

[epeshk]

Ok, understand that, it is probably not better than just:

public static ValueTask WithoutResult<T>(ValueTask<T> task)
{
  if (task.IsCompletedSuccessfully)
  {
    task.GetAwaiter().GetResult();
    return default;
  }

  return WithoutResult_Async(task);
}

[AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder))]
private static async ValueTask WithoutResult_Async<T>(ValueTask<T> task) => await task;