How to use Get method of PuppeteerSharp.Mobile.DeviceDescriptors class

I found a few issues in your code. First a few small errors in your javascript code: you don't need to async and an extra brackets.

var jsCode = @"() => {
  const element = document.querySelector('.productDetail svg[viewbox=""0 0 16 16""]');
  return window.getComputedStyle(element).getPropertyValue('color');
}";

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.

Try upgrading PuppeteerSharp. Upgrading from 1.2 to 2.x fixed this for me.

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

await page.WaitForSelectorAsync(".someSelector");

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.

Set the Headless to true nad try

var options = new LaunchOptions
{
    Headless = true,
    ExecutablePath = @"C:\Program Files\Mozilla Firefox\firefox.exe",
    Args = argumentsWithoutExtension
};

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"
}));

System.ValueTuple was added in .NET 4.7. Upgrading your project to 4.7 would be easiest.

If you can't, but your project is targetting a version 4.5+ but less than 4.7, then you can install the System.ValueTuple NuGet package. If you run into any trouble there, see this answer.