Why is there no ManualResetValueTaskSourceCore that returns a plain ValueTask object.

[migoldfinger]

For Tasks you have
TaskCompletionSource that returns a Task
TaskCompletionSource<T> that returns a Task<T>

For ValueTask despite the fact there is a ValueTask object and a ValueTask<T> object.
There is no ManualResetValueTaskSourceCore that can generate a ValueTask.

The reason I am asking is that I have a Source generator that wraps around an existing class adding logs to existing methods.
For async methods and methods retuning Task and Task<T> the solution was using TaskCompletionSource.
However, using ManualResetValueTaskSourceCore<T> did not work with ValueTypes because I cannot create the non-generic one.

For example my solution for task looks like (task is returned by the wrapped method):

return $$"""
         var tcs = new TaskCompletionSource{{ExtractContentWithinBrackets(returnType)}}();
         task.ContinueWith(t =>
         {
             if (t.IsFaulted)
             {
                 _logger.LogError(t.Exception, "An error occurred in method.");
                 tcs.TrySetException(t.Exception!);
             }
             else if (t.IsCanceled)
             {
                 _logger.LogWarning("Method was canceled.");
                 tcs.TrySetCanceled();
             }
             else
             {
                 _logger.LogDebug({{exitLogMessage}});
                 {{resultHandling}}
             }
         }, TaskContinuationOptions.ExecuteSynchronously);
         return tcs.Task;
         """;

However the same solution for ValueTask will only work for the ValueTask<> variants:

return $$"""
         var valueTaskSource = new ManualResetValueTaskSourceCore{{ExtractContentWithinBrackets(returnType)}}();
         task.AsTask().ContinueWith(t =>
         {
             if (t.IsFaulted)
             {
                 _logger.LogError(t.Exception, "An error occurred in method.");
                 valueTaskSource.SetException(t.Exception!);
             }
             else if (t.IsCanceled)
             {
                 _logger.LogWarning("Method was canceled.");
                 valueTaskSource.SetException(new TaskCanceledException());
             }
             else
             {
                 _logger.LogDebug({{exitLogMessage}});
                 {{resultHandling}}
             }
         }, TaskContinuationOptions.ExecuteSynchronously);
         return new ValueTask{{ExtractContentWithinBrackets(returnType)}}(valueTaskSource, 0);
         """;

How can I achieve this for the non-generic ValueTask.

The workaround I found is to use the implementation for Tasks and return a return new ValueTask(tcs.Task); or return new ValueTask<T>(tcs.Task); at the end. But that would defeat the purpose of using ValueTask, at least I think so.

[MihaZupan]

Why not use regular async? It's way simpler to write, understand, and also cheaper/faster.

ManualResetValueTaskSourceCore is great for cases where you can reuse it, not so much for one-off tasks.

var valueTaskSource = new ManualResetValueTaskSourceCore<T>();
return new ValueTask<T>(valueTaskSource, 0);

ManualResetValueTaskSourceCore isn't an IValueTaskSource, it's the thing you use to implement a type that is.
Your type that uses it is free to implement both IValueTaskSource and IValueTaskSource<T> using the same source.
E.g. here's an example in Socket code:

runtime/src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.Tasks.cs

Line 999 in 0f2bfae

internal sealed class AwaitableSocketAsyncEventArgs : SocketAsyncEventArgs, IValueTaskSource, IValueTaskSource<int>, IValueTaskSource<Socket>, IValueTaskSource<SocketReceiveFromResult>, IValueTaskSource<SocketReceiveMessageFromResult>

[gfoidl]

I agree to what @MihaZupan wrote. So more or less for completeness when you don't want to use async / await here and want to rely on a type, then use AsyncValueTaskMethodBuilder instead of the ManualResetValueTaskSourceCore.

BTW: the AVTMB is used by Roslyn to generate the state machine, so it's way easier to just use async / await, as was already written before.

[migoldfinger]

The thing is when using async / await
It may be easier to read bit it raises some questions
The code itself is an adaption of an old transparent proxy I wrote for that purpose at a time when PTL was young and async/await as well as ValueTask did not exist.
I am not sure how to add the cancel and error log messages. Is listening to the various Exception Types really the same?
However AsyncValueTaskMethodBuilder sounds great I will look into it.

[teo-tsirpanis]

You can just add a try/catch block around the await and do the logging before rethrowing the exception.

[MihaZupan]

Alternatively you can await ((Task)task).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing); and inspect the Task the same way you are doing now.

[petrroll]

Which is more performant btw. We had extensions in our codebase very similar to what you're describing and (even though not perfect) benchmarking heavily suggested it being worse than equivalent with async await and suppressing throwing.