You can wait for some selector that might tell you that the page is ready. e.g.:

await page.WaitForSelectorAsync(".someSelector");

Just replacing navigation with WaitUntilNavigation.Networkidle2 worked to wait until Javascript is finished to excute.

using PuppeteerSharp;

await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);
Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = true // false if you need to see the browser
});
var page = await browser.NewPageAsync();
page.DefaultTimeout = 5000; // or you can set this as 0
await page.GoToAsync("https://www.google.com", WaitUntilNavigation.Networkidle2);
var content = await page.GetContentAsync();

Console.WriteLine(content);

We cannot convert the whole code for you but here are some pointers. You need to take one chunk of problem at a time.

Break the while loop

Let us look into the JS code,

let count = 0;
while (await page.$('#search-content button.btn-icon') !== null && count != 1) {}

It's creating a while look, which stops if count is 1.

Now your C# Code,

while (await page.QuerySelectorAsync("#search-content button.btn-icon") != null)

It's not checking for count, this will end up in infinite while loop.

You should count the number,

int count = 0;
while (await page.QuerySelectorAsync("#search-content button.btn-icon") != null && count != 1){
 // other code
 count++;
}

This way it will stop after it finds one result.

Learn more about Promise.all etc.

Your rest of the question is about Promise.all and few other stuff. Here are some useful links,

• Promise.all()
• API Documentation for Puppeteer Sharp
• API Documentation for Puppeteer

I found a lib called puppeteer, and it has .net version puppeteer-sharp.

Technically speaking this a missing feature on the Linq methods. It's not so simple to code Async Linq functions.

On the other side, I find this much more simple to implement straight in javascript. Why? because you can test your script in your browser and then just move it to your C# code.

For instance, this method will find all li elements, find the li with a span with the text fire and then click the input.

await page.EvaluateFunctionAsync(@"() => {
     Array.from(document.querySelectorAll('li'))
         .find(l => l.querySelector('span').innerText === 'fire').querySelector('INPUT').click();
}");

Although there are still many improvements going on, Puppeteer-Sharp is thread-safe. To improve loading performance, there are a few approaches you can take.

Launch one browser and then connect to it

You can launch one (real) browser and then use the ConnectAsync method to connect to it.

await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);
var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = false,
});

var theBrowser1 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserWSEndpoint = browser.WebSocketEndpoint });
var theBrowser2 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserWSEndpoint = browser.WebSocketEndpoint });
var page1 = await theBrowser1.NewPageAsync();
var page2 = await theBrowser2.NewPageAsync();

await Task.WhenAll(
    page1.GoToAsync("https://www.stackoverflow.com"),
    page2.GoToAsync("https://serverfault.com/")
);

I know that code is not running in parallel, but you'll get the idea about reusing the same browser.

Create new pages on the same browser

If you are using TPL, you shouldn't have any issues creating new pages from different threads using the same browser.

await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);
var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = false,
});

var urls = new string[]
{
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com",
    "https://www.stackoverflow.com"
};

await Task.WhenAll(
    urls.Select(url => Task.Factory.StartNew(async () =>
    {
        var page = await browser.NewPageAsync();
        return page.GoToAsync(url);
    })));

Again, this example is just to give you an idea of how this could be accomplished.

Pages queue

There is one user who created a queue of X pages (for x from 0 to X => NewPage) and then he would grab pages from that queue. You can see the example here.

The following code was working fine:

await page.WaitForSelectorAsync(".event"); // wait ajax completion
var divs = await page.QuerySelectorAllAsync(".event__header--no-my-games > .event__info");

foreach(var cd in divs)
{
   await cd.ClickAsync();
}

the problem was that the browser opened by Puppeteer had mobile dimension, in that case the selectors that I was looking for was differents.

I fixed that declaring a Viewport size in the following way:

Browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
      Headless = true,
      ExecutablePath = "your chrome path",
      DefaultViewport = new ViewPortOptions { Height = 1280, Width = 800}
});

this will open the site in desktop mode with correct selectors.

Hope this help someone.

Technically speaking this a missing feature on the Linq methods. It's not so simple to code Async Linq functions.

On the other side, I find this much more simple to implement straight in javascript. Why? because you can test your script in your browser and then just move it to your C# code.

For instance, this method will find all li elements, find the li with a span with the text fire and then click the input.

await page.EvaluateFunctionAsync(@"() => {
     Array.from(document.querySelectorAll('li'))
         .find(l => l.querySelector('span').innerText === 'fire').querySelector('INPUT').click();
}");

You can use the selectors #login-form-username and #login-form-password, those are the IDs.