How to use RuntimeGetPropertiesRequest class of PuppeteerSharp.Messaging package

Try this:

public static async Task<string> ExportPdfASync(string url, string location)
{
 try
 {
   using (var browser = await Puppeteer.LaunchAsync(LaunchOptions))
   using (var page = await browser.NewPageAsync())
   {
    await page.SetViewportAsync(new ViewPortOptions() { Width = 1440, Height = 990, IsMobile = false, DeviceScaleFactor = 1.0 });

    await page.SetJavaScriptEnabledAsync(true);
    await page.GoToAsync(url);
    await page.WaitForTimeoutAsync(1500);

    var marginOptions = new MarginOptions()
    {
        Top = "10mm",
        Left = "10mm",
        Right = "10mm",
        Bottom = "10mm"
    };

    var pdfOptions = new PdfOptions()
    {
        PrintBackground = true,
        Format = PaperFormat.A4,
        MarginOptions = marginOptions,
        Landscape = landscape
    };
    await page.PdfAsync(location, pdfOptions);
  }
  }
  catch (Exception ex)
  {
  }
  finally {
    browser.CloseAsync();
    page.CloseAsync();
  }
  return "";
}

I think you will find easy to translate the code from puppeteer recorder to Puppeteer-Sharp. At least you can get the selectors from there.

Once you have those selectors you could do 3 things:

One option is setting a directory where the browser can store the cookies using the UserDataDir property. You could open the browser BrowserFetcher downloads and click that button.

A better solution is executing a script using EvaluateFunctionAsync to check if you have the cookies button and click it (using the selector you got from the recorder). Your code will be more flexible.

Last option would be downloading Chromie 77 or higher and launch it using ExecutablePath.

That's an array in the browser. If you want to get that array on your site, you can use the GetPropertiesAsync method. It should be something like this:

var properties = await elements.GetPropertiesAsync().ConfigureAwait(false);
var elementsArray = properties.Values.OfType<ElementHandle>().ToArray();

So my problem was happening because errors are apparently not serializable in javascript land, so we need to get the browser to run a function to extract the message and any other details we need from the error and return that.

This is what's working for me right now:

_page.Console += async (sender, args) =>
{
    switch (args.Message.Type)
    {
        case ConsoleType.Error:
            try
            {
                var errorArgs = await Task.WhenAll(args.Message.Args.Select(arg => arg.ExecutionContext.EvaluateFunctionAsync("(arg) => arg instanceof Error ? arg.message : arg", arg)));
                _logger.LogError($"{args.Message.Text} args: [{string.Join<object>(", ", errorArgs)}]");
            }
            catch { }
            break;
        case ConsoleType.Warning:
            _logger.LogWarning(args.Message.Text);
            break;
        default:
            _logger.LogInformation(args.Message.Text);
            break;
    }
};

I got the idea from a comment from one of the puppeteer contributors here and ported it to pupeteer-sharp.

The way it's supposed to be done atm is like this:

page.on('console', async msg => {
  // serialize my args the way I want
  const args = await Promise.all(msg.args.map(arg => arg.executionContext().evaluate(arg => {
    // I'm in a page context now. If my arg is an error - get me its message.
    if (arg instanceof Error)
      return arg.message;
    // return arg right away. since we use `executionContext.evaluate`, it'll return JSON value of
    // the argument if possible, or `undefined` if it fails to stringify it.
    return arg;
  }, arg)));
  console.log(...args);
});

You don't need to call Dispose if you call CloseAsync. Dispose is just a fire and forget call to CloseAsync. See.

First, the evaluate function won't get what you write in the console.log. You need to return something. As you are waiting for an event you can return a promise and resolve that promise inside the event.

page.EvaluateFunctionAsync<Point>(@"() => {
  return new Promise(resolve => {
    document.onmousemove = function(e){
      mouseX = e.offsetX;
      mouseY = e.offsetY;
      resolve({x: mouseX, y: mouseY});
    };
  });
}");

I found a solution: If the pages will be created in the same scope as their browser instance, then the pages will be created as expected, otherwise Task.Run() will be stuck due to NewPageAsync() method.

Bad behaviour:

Task[] Tasks = new Task[1];
Browser browser = await Puppeteer.LaunchAsync
(
    new LaunchOptions
    {
        Headless = true,
        ExecutablePath = "Chromium\\chrome.exe"
    }
);
for (int i = 0; i < Tasks.Length; i++)
{
    int ThreadNumber = i;
    Tasks[i] = Task.Run(async () =>
    {
       Page page = await browser.NewPageAsync(); //stucks
    });
}

Task.WaitAll(Tasks);

As expected:

Task[] Tasks = new Task[1];
for (int i = 0; i < Tasks.Length; i++)
{
    int ThreadNumber = i;
    Tasks[i] = Task.Run(async () =>
    {
       Browser browser = await Puppeteer.LaunchAsync
       (
           new LaunchOptions
           {
                Headless = true,
               ExecutablePath = "Chromium\\chrome.exe"
           }
       );
       Page page = await browser.NewPageAsync(); //creates as expected
    });
}

Task.WaitAll(Tasks);

Anyway this is not the best solution because I have to create browsers for async tasks rather than using one browser for all async tasks. Hope someone can explain that. Thanks everyone for helping!

Yarp Reverse proxy with Direct Forwarding is the answer:

Server code: (ASP.NET core minimal API):

Dictionary<string, string> routes = new();

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.Map("/connect/{**catch-all}", async httpContext =>
    {
        var route = httpContext.Request.GetDisplayUrl();

        await app.Services.GetRequiredService<IHttpForwarder>().SendAsync(
            httpContext,
            routes.TryGetValue(Path.GetFileName(new Uri(route).AbsolutePath), out string targetRoute) ? targetRoute : route,
            new HttpMessageInvoker(new SocketsHttpHandler()
            {
                UseProxy = false,
                AllowAutoRedirect = false,
                AutomaticDecompression = DecompressionMethods.None,
                UseCookies = false,
                ActivityHeadersPropagator = new ReverseProxyPropagator(DistributedContextPropagator.Current)
            })
        );
    });
});

app.MapGet("/", async () =>
{
    var b = await Puppeteer.LaunchAsync(new()
    {
        ExecutablePath = browserPath // set your chrome directory
    });

    var id = Path.GetFileName(b.WebSocketEndpoint);

    routes.Add(id, b.WebSocketEndpoint);

    return $"ws://your-server-ip-address/connect/{id}";
});

app.Run();

Client code:

await Puppeteer.ConnectAsync(new() { BrowserWSEndpoint = await httpClient.GetStringAsync("http://your-server-ip-address") })

You can use the PdfOptions.Height and PdfOptions.Width.You might find that it's not pixel perfect but that's more on the Chromium's side than on Puppeteer's.

await page.SetViewportAsync(new ViewPortOptions()
{
    Height = 1024,
    Width = 1280
});
await page.GoToAsync("https://github.com/kblok/puppeteer-sharp/");
int height = await page.EvaluateExpressionAsync<int>("document.body.offsetHeight");
int width = await page.EvaluateExpressionAsync<int>("document.body.offsetWidth");
await page.PdfAsync(Path.Combine(Directory.GetCurrentDirectory(), "test.pdf"), new PdfOptions
{
    Width = width.ToString() + "px",
    Height = height.ToString() + "px",
});