Correct approach to wait for multiple async methods to complete
Your code is absolutely correct in case when you want to start workflows only when all of them are configured.

But if you want to start each workflow once it's configured (independently from other workflows) then it might be a good idea to use continuations... In .NET 4.5 it would look like this:

public sealed class Engine : IEngine
{
    private readonly List&lt;IWorkflow&gt; _workflows;

    public Engine(IEnumerable&lt;IWorkflow&gt; workflows)
    {
        _workflows = new List&lt;IWorkflow&gt;(workflows);
    }

    private async Task RunWorkflow(IWorkflow workflow)
    {
        await workflow.ConfigureAsync();
        await workflow.StartAsync();
    }

    public void Start()
    {
        var startTasks = this._workflows.Select(RunWorkflow).ToArray();
        Task.WaitAll(startTasks);
    }

    public void Stop()
    {
        var stopTasks = _workflows.Select(w =&gt; w.StopAsync()).ToArray();
        Task.WaitAll(stopTasks);
    }
}


Also I would suggest to use CancellationToken to stop asynchronous processing.

UPDATE Based on comments it is really needed to wait for all workflows to be configured before starting them. So cancellable implementation can look like this:

public interface IWorkflow
{
    Task ConfigureAsync(CancellationToken token);
    Task StartAsync(CancellationToken token);
}

public sealed class Engine : IEngine
{
    private readonly List&lt;IWorkflow&gt; _workflows;
    private readonly CancellationTokenSource _cancellationTokenSource;
    private Task _mainTask;

    public Engine(IEnumerable&lt;IWorkflow&gt; workflows)
    {
        _workflows = new List&lt;IWorkflow&gt;(workflows);
        _cancellationTokenSource = new CancellationTokenSource();
    }

    private async Task RunWorkflows()
    {
        await Task.WhenAll(_workflows.Select(w =&gt; w.ConfigureAsync(_cancellationTokenSource.Token)));
        if (_cancellationTokenSource.IsCancellationRequested)
            return;
        await Task.WhenAll(_workflows.Select(w =&gt; w.StartAsync(_cancellationTokenSource.Token)));
    }

    public void Start()
    {
        _mainTask = RunWorkflows();
        _mainTask.Wait();
    }

    public void Stop()
    {
        _cancellationTokenSource.Cancel();
        var mainTask = _mainTask;
        if (mainTask != null)
            mainTask.Wait();
    }
}