Удалите метод async и ожидайте с помощью await foreach

Довольно странно просто не использовать асинхронное выполнение, когда это возможно, но я оставлю это на ваше усмотрение. Просто помните о рисках взаимоблокировок и снижения производительности.

Если вам действительно не нужно использовать await, вот реализация без него. Немного многословно и не так чисто, как с await, но вот оно.

Во-первых, давайте определим пример метода, возвращающего IAsyncEnumerable:

public static class TestClass
{
    public static async IAsyncEnumerable<int> GetIntsAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(100);
            yield return i;
        }
    }
}

и реализация без await будет:

var asyncEnumerator = TestClass.GetIntsAsync().GetAsyncEnumerator();
try
{
    while (asyncEnumerator.MoveNextAsync().AsTask().GetAwaiter().GetResult())
    {
        Console.WriteLine(asyncEnumerator.Current);
    }
}
finally
{
    asyncEnumerator?.DisposeAsync().AsTask().GetAwaiter().GetResult();
}

Для удобства вы можете определить методы расширения для таких сценариев:

public static class Extensions
{
    public static T AwaitSynchornously<T>(this ValueTask<T> valueTask)
    {
        return valueTask.AsTask().GetAwaiter().GetResult();
    }

    public static void AwaitSynchornously(this ValueTask valueTask)
    {
        valueTask.AsTask().GetAwaiter().GetResult();
    }

    public static T[] LoopSynchronously<T>(
        this IAsyncEnumerable<T> asyncEnumerable,
        Action<T> action)
    {
        return asyncEnumerable.EnumerateSynchronously(action).ToArray();
    }

    public static IEnumerable<T> EnumerateSynchronously<T>(
        this IAsyncEnumerable<T> asyncEnumerable,
        Action<T> action)
    {
        var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
        try
        {
            while (asyncEnumerator.MoveNextAsync().AwaitSynchornously())
            {
                action(asyncEnumerator.Current);
                yield return asyncEnumerator.Current;
            }
        }
        finally
        {
            asyncEnumerator?.DisposeAsync().AwaitSynchornously();
        }
    }
}

Использование тогда очень просто:

TestClass.GetIntsAsync().LoopSynchronously(Console.WriteLine);

Вы можете использовать API .NET 7 ToBlockingEnumerable:

Преобразует экземпляр IAsyncEnumerable<T> в экземпляр IEnumerable<T>, который перечисляет элементы блочным способом.

Пример использования:

public static void Run(IMinioClient minio,
    string bucketName = "my-bucket-name",
    string prefix = null,
    bool recursive = true,
    bool versions = false)
{
    var listArgs = new ListObjectsArgs()
        .WithBucket(bucketName)
        .WithPrefix(prefix)
        .WithRecursive(recursive)
        .WithVersions(versions);

    foreach (var item in minio.ListObjectsEnumAsync(listArgs).ToBlockingEnumerable())
    {
        Console.WriteLine($"Object: {item.Key}");
    }
}

Это решение подвержено взаимоблокировкам в зависимости от реализации метода ListObjectsEnumAsync. Блокировка по асинхронному коду вообще нецелесообразна.