foreach (var item in items)
{
    await DoTaskAsync(item).ConfigureAwait(false);
}

if (Shared.A > Shared.B)
  Shared.A = Shared.B

public class AsyncProducerConsumerCollection<T>
{
    private readonly Queue<T> m_collection = new Queue<T>();
    private readonly Queue<TaskCompletionSource<T>> m_waiting = 
        new Queue<TaskCompletionSource<T>>();

    public void Add(T item)
    {
        TaskCompletionSource<T> tcs = null;
        lock (m_collection)
        {
            if (m_waiting.Count > 0) tcs = m_waiting.Dequeue();
            else m_collection.Enqueue(item);
        }
        if (tcs != null) tcs.TrySetResult(item);
    }

    public Task<T> Take()
    {
        lock (m_collection)
        {
            if (m_collection.Count > 0) 
            {
                return Task.FromResult(m_collection.Dequeue()); 
            }
            else 
            {
                var tcs = new TaskCompletionSource<T>();
                m_waiting.Enqueue(tcs);
                return tcs.Task;
            }
        }
    }
}

private static AsyncProducerConsumerCollection<int> m_data = …;
…
private static async  Task ConsumerAsync()
{
    while(true)
    {
        int nextItem = await m_data.Take();
        ProcessNextItem(nextItem);
    }
}
…
private static void Produce(int data)
{
    m_data.Add(data);
}

private static BufferBlock<int> m_data = …;
…
private static async  Task ConsumerAsync()
{
    while(true)
    {
        int nextItem = await m_data.ReceiveAsync();
        ProcessNextItem(nextItem);
    }
}
…
private static void Produce(int data)
{
    m_data.Post(data);
}

public Task<T> Take()
    {
        lock (m_collection)
        {

// Если в очереди есть значения то сразу возвращаем значение
// Task.FromResult(m_collection.Dequeue()); 
            if (m_collection.Count > 0) 
            {
                return Task.FromResult(m_collection.Dequeue()); 
            }
            else 
            {
// Если нет сообщений то возвращаем TaskCompletionSource
                var tcs = new TaskCompletionSource<T>();
                m_waiting.Enqueue(tcs);
                return tcs.Task;
            }
        }
    }

public void Add(T item)
    {
        TaskCompletionSource<T> tcs = null;
        lock (m_collection)
        {
// Если есть ожидание то получим TaskCompletionSource
            if (m_waiting.Count > 0) tcs = m_waiting.Dequeue();
            else m_collection.Enqueue(item);
        }

// И установим добавляемое значение в результат ожидаемой задачи
        if (tcs != null) tcs.TrySetResult(item);
    }

var t = SetFlagAsync();
while (await CheckFlag())
{ ... }
await t;

S>var t = SetFlagAsync();
S>while (await CheckFlag())
S>{ ... }
S>await t;
S>

S>не хотите?

не хочет синзронизировать доступ к общим переменным между await-ами

while (true)
{
  var t=await ВозьмемИзFIFOЗамыкание();

   t();

 }

var t = SetFlagAsync(); // Кладём в очередь задачу "установить флаг"
while (true)
{ 
  var task = CheckFlag(); // Кладём в начало очереди задачу "проверить флаг"
  var result = await CheckFlag(); 
  //запускаем очередь на выполнение, выполняется CheckFlag, флаг ещё не установлен, кладём в начало очереди задачу "продолжить, результат - false".
  if (result) break;
}
await t; // сюда не доходим.

S>var t = SetFlagAsync(); // Кладём в очередь задачу "установить флаг"
S>while (true)
S>{ 
S>  var task = CheckFlag(); // Кладём в начало очереди задачу "проверить флаг"
S>  var result = await CheckFlag(); 
S>  //запускаем очередь на выполнение, выполняется CheckFlag, флаг ещё не установлен, кладём в начало очереди задачу "продолжить, результат - false".
S>  if (result) break;
S>}
S>await t; // сюда не доходим.
S>

public Task<T> Take()
    {
        lock (m_collection)
        {

// Если в очереди есть значения то сразу возвращаем значение
// Task.FromResult(m_collection.Dequeue()); 
            if (m_collection.Count > 0) 
            {
                return Task.FromResult(m_collection.Dequeue()); 
            }
            else 
            {
// Если нет сообщений то возвращаем TaskCompletionSource
// и по сути там будет только 1 элемент в очереди

                var tcs = new TaskCompletionSource<T>();
                m_waiting.Enqueue(tcs);
                return tcs.Task;
            }
        }
    }

public void Add(T item)
    {
        TaskCompletionSource<T> tcs = null;
        lock (m_collection)
        {
// Если есть ожидание то получим TaskCompletionSource
// m_waiting.Count будет либо 0 либо 2
            if (m_waiting.Count > 0) tcs = m_waiting.Dequeue();
            else m_collection.Enqueue(item);
        }

// И установим добавляемое значение в результат ожидаемой задачи
// Очередь TaskCompletionSource пуста.
        if (tcs != null) tcs.TrySetResult(item);
    }