How to use ProfilerTakePreciseCoverageResponseFunction class of PuppeteerSharp.Messaging package

First thing, you need to launch Chrome with remote debugging enabled. If you launch Chrome, for instance, with the flag --remote-debugging-port=2122, you know that you will be able to connect to the browser using the http://127.0.0.1:2122 URL.

Second, if you want to connect to an existing browser you need to call ConnectAsync instead of LaunchAsync.

Having all that. If would be a matter of doing something like this:

var browser = await Puppeteer.ConnectAsync(new ConnectOptions
{
    BrowserURL = "http://127.0.0.1:2122"
}));

The content you trying to scrape here is inside iframe.
To access it you have to switch to that iframe.
See here example how to switch to iframe with BeautifulSoup.
Here example with Selenium scraping inside iframe.
And here with puppeteersharp

I found no way to do this in modern versions of Chrome because Page.setDownloadBehavior is removed from CDP v1.3 https://chromedevtools.github.io/devtools-protocol/1-3.

UPD: this work https://gist.github.com/vabka/88a9b054ee756a53a44691366b16b474

I solved the problem like this.

const links = await page.evaluate(() =>
              Array.from(document.querySelectorAll('a span'), e => 
              e.textContent));

This is how you can use System.Net.WebSockets.Managed on Puppeteer-Sharp

var browserOptions = new LaunchOptions
{
    Headless = true,
    WebSocketFactory = (uri, socketOptions, cancellationToken)
        => System.Net.WebSockets.SystemClientWebSocket.ConnectAsync(uri, cancellationToken)
};
using (var browser = await Puppeteer.LaunchAsync(browserOptions))
using (var page = await browser.NewPageAsync())
{

}

Wait and await - while similar conceptually - are actually completely different.

Wait will synchronously block until the task completes. So the current thread is literally blocked waiting for the task to complete. As a general rule, you should use "async all the way down"; that is, don't block on async code. On my blog, I go into the details of how blocking in asynchronous code causes deadlock.

await will asynchronously wait until the task completes. This means the current method is "paused" (its state is captured) and the method returns an incomplete task to its caller. Later, when the await expression completes, the remainder of the method is scheduled as a continuation.

You also mentioned a "cooperative block", by which I assume you mean a task that you're Waiting on may execute on the waiting thread. There are situations where this can happen, but it's an optimization. There are many situations where it can't happen, like if the task is for another scheduler, or if it's already started or if it's a non-code task (such as in your code example: Wait cannot execute the Delay task inline because there's no code for it).

You may find my async / await intro helpful.

You can do something like this:

await page.EvaluateExpressionAsync("document.querySelectorAll('SCRIPT').forEach(e => e.remove())");

I found this is the most scalable way to implement this is by using a background process. This is one real-life example:

1. A WebClient request a PDF sending a signalR message.
2. The SignalR hub creates some kind of an ID, put the request in an Azure Queue, and adds the SignalR client to a SignalR group with that ID.
3. A console app would read that queue, process the HTML, and sends back the result to the server using a SignalR message.
4. The WebServer will get the message, and broadcast that message to all the clients in that group.

It might sound quite complicated, but it's not that much. You can make it simpler.

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.