How to properly wait for conditions to be met before continuing to execute subsequent code?

We need to make sure some conditions are met before executing the subsequent code, is there a better way to replace the while loop?

bool conditionA; // set in another Task
bool conditionB; // set in another Task

private async Task HandleData()
{
    await Task.Run(() =>
    {
        while (!(this.conditionA && this.conditionB))
        {
            // do nothing here
        }
    });

    // next steps
    // ...
    // next steps
}

Note: Method HandleData may be triggered before conditionA and conditionB are assigned.

Can it be implemented using custom events?

You can use TaskCompletionSource for this purpose

var tcsa = new TaskCompletionSource();
var tcsb = new TaskCompletionSource();

Task.Run(async () => {
  await Task.Delay(10000);
  tcsa.SetResult();
  // or tcsa.TrySetResult();
});

Task.Run(async () => {
  await Task.Delay(10000);
  tcsb.SetResult();
  // or tcsb.TrySetResult();
});

// Wait for both sources to complete
await Task.WhenAll(tcsa.Task, tcsb.Task);

it is also possible to use Generic TaskCompletionSource in case you want to return some value to the core after signal.

You could do this by replacing the bool values with ManualResetEventSlim and then using WaitHandle.WaitAll to wait for both the conditions to become signalled.

Sample compilable console application:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Console1
{
    public static class Program
    {
        public static void Main()
        {
            using var conditionA = new ManualResetEventSlim(initialState: false);
            using var conditionB = new ManualResetEventSlim(initialState: false);

            Task.Run(() => signalAfterDelay(conditionA, TimeSpan.FromSeconds(4)));
            Task.Run(() => signalAfterDelay(conditionB, TimeSpan.FromSeconds(8)));
        
            Console.WriteLine("Main thread waiting for completion.");

            waitForCompletion(conditionA.WaitHandle, conditionB.WaitHandle);

            Console.WriteLine("Main thread finished waiting for completion.");
            Console.ReadLine();
        }

        static void signalAfterDelay(ManualResetEventSlim condition, TimeSpan delay)
        {
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} is sleeping for {delay}");
            Thread.Sleep(delay);
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} is signalling the condition");
            condition.Set();
        }

        static void waitForCompletion(WaitHandle conditionA, WaitHandle conditionB)
        {
            Console.WriteLine("Waiting for both conditions to become true");

            WaitHandle.WaitAll(new[] { conditionA, conditionB });

            Console.WriteLine("Finished waiting for both conditions to become true");
        }
    }
}

Note that this code assumes that the conditions are only signalled once. If they must be reset, then how to do that is outside the scope of your question as it currently stands, since it contains no information about the state under which the conditions are reset.

I usually write some light extensions for those problems:

public static class DelayHelper
{
    public const double GoldenRatio = 1.61803398874989484820458683436;
    
    /// <summary>
    /// Wait until condition is true.
    /// </summary>
    /// <param name="condition"></param>
    /// <param name="ct"></param>
    /// <param name="delayProvider">By default this function checks condition with exponentially increasing delay. The best base was calculated to be GoldenRation and delay capped at 5 seconds,
    /// other bases give chaotic losses in time but can improve check performance. 5 second cap used solely because checks considered to be fast. For longer operations its better to use longer cap.</param>
    /// <returns></returns>
    public static async Task WaitTrueAsync(Func<Task<bool>> condition, CancellationToken ct, Func<int, TimeSpan> delayProvider = null)
    {
        delayProvider ??= x => ExponentialDelayPolicy(x, TimeSpan.FromMilliseconds(1), TimeSpan.FromSeconds(5));
        for (var i = 0; ; i++)
        {
            if (!await condition().ConfigureAwait(false))
            {
                break;
            }
            await Task.Delay(delayProvider(i), ct).ConfigureAwait(false);
        }
    }
    
    public static TimeSpan ExponentialDelayPolicy(int index, TimeSpan minDelay, TimeSpan maxDelay, double @base = GoldenRatio)
    {
        var maxIndex = (int)Math.Ceiling(Math.Log(maxDelay.Ticks / (double)minDelay.Ticks, @base));
        var delay = TimeSpan.FromTicks(index < maxIndex
            ? (long)Math.Ceiling(Math.Min(minDelay.Ticks * Math.Pow(@base, index), maxDelay.Ticks))
            : maxDelay.Ticks);
        return delay;
    }
    
    public static TimeSpan ConstantDelayPolicy(TimeSpan delay)
    {
        return delay;
    }
}

Usage will wait until condition is met, then you can set something:

await DelayHelper.WaitTrueAsync(()=> !(this.conditionA && this.conditionB), ct);

//do something here

Of course if you can change conditionA/B - it is better replace them with TaskCompletionSource and just wait for it to complete. My extension is primarly pull model for some events rised over slow transports - network, files, etc.

PS Exponential delay policy is usually better for IO, but you can just set some constant delay there if you think it is slow.