Using async Tasks with the builder pattern

As I said in comments, you could write Extension method for HomeViewModelBuilder as well as Task<HomeViewModelBuilder> and chain it.

public static class HomeViewModelBuilderExtension
{
    public static Task<HomeViewModelBuilder> WithCarousel(this HomeViewModelBuilder antecedent)
    {
        return WithCarousel(Task.FromResult(antecedent));
    }

    public static async Task<HomeViewModelBuilder> WithCarousel(this Task<HomeViewModelBuilder> antecedent)
    {
        var builder = await antecedent;
        var carouselItems = await builder.Service.GetAsync();
        builder.ViewModel.Carousel = carouselItems;
        return builder;
    }

    public static Task<HomeViewModelBuilder> WithFeaturedItems(this HomeViewModelBuilder antecedent, int number)
    {
        return WithFeaturedItems(Task.FromResult(antecedent), number);
    }

    public static async Task<HomeViewModelBuilder> WithFeaturedItems(this Task<HomeViewModelBuilder> antecedent, int number)
    {
        var builder = await antecedent;
        builder.ViewModel.FeaturedItems = number;
        return builder;
    }
}

We're adding couple of methods for single operation so that you can chain it with HomeViewModelBuilder or Task<HomeViewModelBuilder>. Otherwise you'll not be able to call builder.WithCarousel()

Then use it like

private static void Main()
{
    HomeViewModelBuilder builder = new HomeViewModelBuilder();
    var task = builder
        .WithCarousel()
        .WithFeaturedItems(3);        
}

With the builder pattern you can create a strategy of building the object. It does not construct the object until the build method is called. If the logic to populate the object is in the build method then you can call all of the async methods together.

See example code for your builder below. Its just a demonstration of the concept so you may want to improve on it.

    public class Builder
    {
        private bool hasCarousel = false;
        private int featuredItems = 0;

        public Builder WithCarousel()
        {
            hasCarousel = true;
            return this;
        }

        public Builder WithFeaturedItems(int featured)
        {
            featuredItems = featured;
            return this;
        }

        public BuiltObject Build()
        {
            if (hasCarousel)
            {
                // do carousel related calls
            }
            if (featuredItems > 0)
            {
                // do featured items related calls.
            }

            // build and return the actual object.
        }
    }

The deal with async, is that it has the ripple effect. It tends to spread through your code to keep it async "async all the way".

If you want to allow for the builder pattern (or any other fluent pattern, like LINQ) while keeping it async you need to have an async overload for each of the possible calls you want to make. Otherwise you can't use them, or will use them wrong (with "sync over async" for example).

async-await is fairly new, but I'm sure over time you will have an async option for almost anything.

The accepted answer was pretty helpful, but I think in some cases (at least in mine) it is more helpful to wait on the builder itself instead of the built objects:

public sealed class HomeViewModelBuilder
{
  
 private List<Task<HomeViewModelBuilder>> taskList= new List<Task<HomeViewModelBuilder>>();

 public HomeViewModelBuilder WithCarousel(){
   taskList.add(WithCarouselInternal());
   return this;
 }

 private async Task<HomeViewModelBuilder> WithCarouselInternal()
  {
    var result = await _service.GetAsync();
    // do something with the result
    return this;
  }

 public HomeViewModelBuilder WithSomthingElse(){
   taskList.add(WithSomethingElseInternal());
   return this;
 }

 (...)


  public async Task<HomeViewModel> BuildAsync()
  {
   await Task.WhenAll(taskList);
   // On that point we can now be sure that all builds are finished
   return new HomeViewModel(...);
  }
}

I hope this is a little more generic, because you just have to keep the taskList up to date and also can call the same build-method more than one time in a simple way (you can't overwrite a previous call to a build method because all will Task will be present in the list and so the build will definitely wait till the Task finishes)

Thank you. Could not find a simple answer anywhere. This helped me wrap Playwright into a builder pattern for async tasks.

using Microsoft.Playwright;

public class PlaywrightService
{
    private readonly IPage _page;

    private PlaywrightService(IPage page)
    {
        _page = page ?? throw new ArgumentNullException(nameof(page));
    }

    public static PlaywrightService Create(IPage page) => new PlaywrightService(page);

    public PlaywrightServiceBuilder NewBuilder() => new PlaywrightServiceBuilder(_page);

    public class PlaywrightServiceBuilder
    {
        private readonly IPage _page;
        private readonly List<Func<Task>> _actions = new List<Func<Task>>();

        public PlaywrightServiceBuilder(IPage page)
        {
            _page = page;
        }
        
        public PlaywrightServiceBuilder Navigate(string url)
        {
            // Wait for page load explicitly.
            _actions.Add(() => _page.GotoAsync(url, new PageGotoOptions { WaitUntil = WaitUntilState.Load }));
            return this;
        }

        public PlaywrightServiceBuilder ClickElement(string selector)
        {
            // Wait for the element to be available before clicking.
            _actions.Add(() => _page.WaitForSelectorAsync(selector, new PageWaitForSelectorOptions { State = WaitForSelectorState.Visible }));
            _actions.Add(() => _page.ClickAsync(selector));

            return this;
        }

        // Deets
        /*
         It does not simulate typing, it *directly sets the value*.
         It clears the field first before entering new text.
         If you need to simulate real keystrokes, use ***_page.TypeAsync(selector, text)***.
         If the input field is not visible or enabled, Playwright will throw an error. */
        public PlaywrightServiceBuilder SetFieldValue(string selector, string text)
        {
            _actions.Add(() => _page.FillAsync(selector, text));
            return this;
        }
        
        // As above - but as if it were actually TYPED MANUALLY
        public PlaywrightServiceBuilder TypeFieldValue(string selector, string text)
        {
            _actions.Add(() => _page.Locator(selector).PressSequentiallyAsync(text));
            return this;
        }
        
        public PlaywrightServiceBuilder GetText(string selector, Action<string> onTextReceived)
        {
            _actions.Add(async () =>
            {
                var text = await _page.InnerTextAsync(selector).ConfigureAwait(false);
                onTextReceived(text);
            });
            return this;
        }

        // If element exists, run the action
        public PlaywrightServiceBuilder IfElementExists(string selector, Func<Task> actionIfExists)
        {
            _actions.Add(async () =>
            {
                var element = await _page.QuerySelectorAsync(selector).ConfigureAwait(false);
                if (element != null)
                {
                    await actionIfExists().ConfigureAwait(false);
                }
            });
            return this;
        }

        // If element exists with an alternative for the "else" case
        public PlaywrightServiceBuilder IfElementExistsWithAlternative(string selector, Func<Task> actionIfExists, Func<Task> actionIfNotExists)
        {
            _actions.Add(async () =>
            {
                var element = await _page.QuerySelectorAsync(selector).ConfigureAwait(false);
                if (element != null)
                {
                    await actionIfExists().ConfigureAwait(false);
                }
                else
                {
                    await actionIfNotExists().ConfigureAwait(false);
                }
            });
            return this;
        }

        // Build and execute the accumulated tasks
        public async Task ExecuteAsync()
        {
            foreach (var action in _actions)
            {
                await action().ConfigureAwait(false);
            }
        }
    }
}

And its finally doing what I need.

await PlaywrightService.Create(page).NewBuilder()
                .Navigate("https://google.com/")
                .IfElementExistsWithAlternative(".gNO89b",
                    async () =>
                    {
                        // If #someElement exists, run this block and stop the outer chain
                        Console.WriteLine("Element exists! Running actions...");
                    },
                    async () =>
                    {
                        // If #someElement doesn't exist, run this block instead and continue
                        Console.WriteLine("Element does not exist! Continuing with other actions...");
                    })
                .IfElementExists("#otherElement", async () =>
                {
                    // Another conditional check for another element
                    Console.WriteLine("Running actions for another element...");
                    await page.ClickAsync("#otherElement");
                })
                .TypeFieldValue("textarea.gLFyf\n", "How duth I google this")
                .ClickElement(".gNO89b") // This will execute only if the outer chain is not stopped
                .ExecuteAsync();