System.InvalidOperationException when using GetAwaiter().GetResult() with ServiceBusReceiver.PeekMessagesAsync

Question

Context

We are using GetAwaiter().GetResult() because PowerShell's Cmdlet.ProcessRecord() does not support async/await.

Code Sample

class Program
{
    static async Task Main(string[] args)
    {
        var topicPath = "some-topic";
        var subscriptionName = "some-subscription";
        var connectionString = "some-connection-string";

        var subscriptionPath = EntityNameHelper.FormatSubscriptionPath(
            topicPath,
            subscriptionName
        );

        var serviceBusClient = new ServiceBusClient(connectionString);
        var receiver = serviceBusClient.CreateReceiver(queueName: subscriptionPath);

        // This one works. :-) 
        await foreach (var item in GetMessages(receiver, maxMessagesPerFetch: 5))
        {
            Console.WriteLine("async/await: " + item);
        }

        // This one explodes.
        var enumerator = GetMessages(receiver, maxMessagesPerFetch: 5).GetAsyncEnumerator();
        while (enumerator.MoveNextAsync().GetAwaiter().GetResult())
        {
            // Unhandled exception. System.InvalidOperationException: Operation is not valid due to the current state of the object.
            //    at NonSync.IAsyncEnumerable.Program.GetMessages(ServiceBusReceiver receiver, Int32 maxMessagesPerFetch)+System.Threading.Tasks.Sources.IValueTaskSource<System.Boolean>.GetResult()
            //    at NonSync.IAsyncEnumerable.Program.Main(String[] args) in C:\dev\mediavalet\MediaValet.Learning\entropy\NonSynchronousDotNet\NonSync.IAsyncEnumerable\Program.cs:line 42
            //    at NonSync.IAsyncEnumerable.Program.<Main>(String[] args)
            Console.WriteLine("GetAwaiter().GetResult(): " + enumerator.Current);
        }
    }

    public static async IAsyncEnumerable<string> GetMessages(
        ServiceBusReceiver receiver,
        int maxMessagesPerFetch
    )
    {
        yield return "Foo";
        var messages = await receiver.PeekMessagesAsync(maxMessagesPerFetch);
        yield return "Bar";
    }
}

Question

What's going on here? How can we fix it without changing GetMessages?

Answer 1

According to the documentation of the ValueTask<TResult> struct:

The following operations should never be performed on a ValueTask<TResult> instance:

• Awaiting the instance multiple times.
• Calling AsTask multiple times.
• Using .Result or .GetAwaiter().GetResult() when the operation hasn't yet completed, or using them multiple times.
• Using more than one of these techniques to consume the instance.

If you do any of the above, the results are undefined.

What you can do is to convert the ValueTask<bool> to a Task<bool>, by using the AsTask method:

while (enumerator.MoveNextAsync().AsTask().GetAwaiter().GetResult())

Answer 2

This answer complements Theodor's answer with a code sample. Our specific problem was that we were calling GetResult() before the ValueTask had completed. The docs specify that that is not allowed:

A ValueTask instance may only be awaited once, and consumers may not read Result until the instance has completed. If these limitations are unacceptable, convert the ValueTask to a Task by calling AsTask. (Emphasis added).

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

var enumerator = GetAsyncEnumerable().GetAsyncEnumerator();

while (true)
{
    var moveNext = enumerator.MoveNextAsync();
    var moveNextAwaiter = moveNext.GetAwaiter();

    Console.WriteLine("ValueTask.IsCompleted: {0}", moveNext.IsCompleted);

    try
    {
        if (moveNextAwaiter.GetResult())
        {
            Console.WriteLine("IAsyncEnumerator.Current: {0}", enumerator.Current);
            continue;
        }

        Console.WriteLine("Done! We passed the end of the collection.");
        break;
    }
    catch (InvalidOperationException)
    {
        Console.WriteLine("Boom! GetResult() before the ValueTask completed.");
        continue;
    }
}

async IAsyncEnumerable<int> GetAsyncEnumerable()
{
    yield return 1;
    await Task.Delay(1000);
    yield return 2; // <---- We never access this, because GetResult() explodes.
    yield return 3;
}

Output:

ValueTask.IsCompleted: True
IAsyncEnumerator.Current: 1

ValueTask.IsCompleted: False
Boom! GetResult() before the ValueTask completed.

ValueTask.IsCompleted: True
IAsyncEnumerator.Current: 3

ValueTask.IsCompleted: True
Done! We passed the end of the collection.