How to use OnExecutionContextCreated method of PuppeteerSharp.Worker class

I think EvaluateFunctionAsync is the most straight forward way to do this:

var type = await node.EvaluateFunctionAsync<string>("node => node.type");

Set the Headless to true nad try

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

You could use a using block for that:

public static async Task<string> renderHtmlAsync(string url2)
{
    await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);
    using (Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions
    {
        Headless = true
    }))
    {
        var page = await browser.NewPageAsync();
        page.DefaultTimeout = 0;
        var navigation = new NavigationOptions
        {
            Timeout = 0,
            WaitUntil = new[] {
                    WaitUntilNavigation.DOMContentLoaded }
        };
        await page.GoToAsync(url2, navigation);
        var content = page.GetContentAsync();

        return await content;
    }
}

This works like:

var myObject = new DispoableObject();
try
{
    // insert code
    return result;
}
finally
{
    myObject.Dispose();
}

The code in the finally is always executed, even when an exception is thrown inside the try block.

You can do something like this:

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

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

The issue was using Action instead of Func<Page, Task>.

Action always returns a void. Since the function Action was calling was a async method but was not sending the method's output it causes the function that called Action to exit which released the unmanged resources. The Func<Page, Task> retains the output so it can be awaited so the main thread is blocked till completion preventing the unmanaged resources from being release early.

async static void Main()
{
   Func<FileStream,Task> func = (FileStream fs) => Foo(fs); //Input to function is FileStream and Output of Function is Task
   Action<FileStream> action = (FileStream fs) => Foo(fs); //Equivalent to Func<FileStream , void>
   using var fs = new FileStream();
   //action(fs); //This can fail if the main thread is finished before it
   await func(fs); //This will succeed since the main thread is blocked till completion

}
async static Task Foo(FileStream fs) => await fs.SomeLongAsyncMethod();

I solved the problem like this.

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

Change your Window_Loaded event method to async and do an await on the Init method, Event Handler methods are an exception. using async void instead of async Task is ok in this scenario. - Reference (Should I avoid 'async void' event handlers?):

private async void Window_Loaded(object sender, RoutedEventArgs e) 
{  
   await Handler.Init(Handler);
}

According to the docs you have ScreenShotDataAsync which returns a byte[]:

byte[] data = await page.ScreenshotDataAsync(scrOpts);

There's also ScreenshotStreamAsync which returns a Stream:

Stream stream = await page.ScreenshotStreamAsync(scrOpts);