How to use JSHandle class of PuppeteerSharp package

...66        /// <param name="script">Script to be evaluated in browser context</param>67        /// <param name="args">Arguments to pass to script</param>68        /// <remarks>69        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.70        /// <see cref="JSHandle"/> instances can be passed as arguments71        /// </remarks>72        /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>73        /// <seealso cref="EvaluateFunctionHandleAsync(string, object[])"/>74        /// <returns>Task which resolves to script return value</returns>75        public Task<JToken> EvaluateFunctionAsync(string script, params object[] args)76            => EvaluateAsync<JToken>(EvaluateFunctionHandleAsync(script, args));77        /// <summary>78        /// Executes a function in browser context79        /// </summary>80        /// <typeparam name="T">The type to deserialize the result to</typeparam>81        /// <param name="script">Script to be evaluated in browser context</param>82        /// <param name="args">Arguments to pass to script</param>83        /// <remarks>84        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.85        /// <see cref="JSHandle"/> instances can be passed as arguments86        /// </remarks>87        /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>88        /// <seealso cref="EvaluateFunctionHandleAsync(string, object[])"/>89        /// <returns>Task which resolves to script return value</returns>90        public Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)91            => EvaluateAsync<T>(EvaluateFunctionHandleAsync(script, args));92        /// <summary>93        /// The method iterates JavaScript heap and finds all the objects with the given prototype.94        /// </summary>95        /// <returns>A task which resolves to a handle to an array of objects with this prototype.</returns>96        /// <param name="prototypeHandle">A handle to the object prototype.</param>97        public async Task<JSHandle> QueryObjectsAsync(JSHandle prototypeHandle)98        {99            if (prototypeHandle.Disposed)100            {101                throw new PuppeteerException("Prototype JSHandle is disposed!");102            }103            if (!((JObject)prototypeHandle.RemoteObject).TryGetValue(MessageKeys.ObjectId, out var objectId))104            {105                throw new PuppeteerException("Prototype JSHandle must not be referencing primitive value");106            }107            var response = await _client.SendAsync("Runtime.queryObjects", new Dictionary<string, object>108            {109                {"prototypeObjectId", objectId.ToString()}110            }).ConfigureAwait(false);111            return CreateJSHandle(response[MessageKeys.Objects]);112        }113        internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)114        {115            if (string.IsNullOrEmpty(script))116            {117                return null;118            }119            try120            {121                return await EvaluateHandleAsync("Runtime.evaluate", new Dictionary<string, object>122                {123                    ["expression"] = _sourceUrlRegex.IsMatch(script) ? script : $"{script}\n{EvaluationScriptSuffix}",124                    ["contextId"] = _contextId,125                    ["returnByValue"] = false,126                    ["awaitPromise"] = true,127                    ["userGesture"] = true128                }).ConfigureAwait(false);129            }130            catch (Exception ex)131            {132                throw new EvaluationFailedException(ex.Message, ex);133            }134        }135        internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params object[] args)136        {137            if (string.IsNullOrEmpty(script))138            {139                return null;140            }141            try142            {143                return await EvaluateHandleAsync("Runtime.callFunctionOn", new Dictionary<string, object>144                {145                    ["functionDeclaration"] = $"{script}\n{EvaluationScriptSuffix}\n",146                    [MessageKeys.ExecutionContextId] = _contextId,147                    ["arguments"] = args.Select(FormatArgument),148                    ["returnByValue"] = false,149                    ["awaitPromise"] = true,150                    ["userGesture"] = true151                }).ConfigureAwait(false);152            }153            catch (Exception ex)154            {155                throw new EvaluationFailedException(ex.Message, ex);156            }157        }158        internal JSHandle CreateJSHandle(dynamic remoteObject)159            => (remoteObject.subtype == "node" && Frame != null)160                ? new ElementHandle(this, _client, remoteObject, Frame.FrameManager.Page, Frame.FrameManager)161                : new JSHandle(this, _client, remoteObject);162        private async Task<T> EvaluateAsync<T>(Task<JSHandle> handleEvaluator)163        {164            var handle = await handleEvaluator.ConfigureAwait(false);165            var result = default(T);166            try167            {168                result = await handle.JsonValueAsync<T>()169                    .ContinueWith(jsonTask => jsonTask.Exception != null ? default : jsonTask.Result).ConfigureAwait(false);170            }171            catch (Exception ex)172            {173                if (ex.Message.Contains("Object reference chain is too long") ||174                    ex.Message.Contains("Object couldn't be returned by value"))175                {176                    return default;177                }178                throw new EvaluationFailedException(ex.Message, ex);179            }180            await handle.DisposeAsync().ConfigureAwait(false);181            return result is JToken token && token.Type == JTokenType.Null ? default : result;182        }183        private async Task<JSHandle> EvaluateHandleAsync(string method, dynamic args)184        {185            var response = await _client.SendAsync(method, args).ConfigureAwait(false);186            var exceptionDetails = response[MessageKeys.ExceptionDetails];187            if (exceptionDetails != null)188            {189                throw new EvaluationFailedException("Evaluation failed: " +190                    GetExceptionMessage(exceptionDetails.ToObject<EvaluateExceptionDetails>()));191            }192            return CreateJSHandle(response.result);193        }194        private object FormatArgument(object arg)195        {196            switch (arg)197            {198                case double d:199                    if (double.IsPositiveInfinity(d))200                    {201                        return new { unserializableValue = "Infinity" };202                    }203                    if (double.IsNegativeInfinity(d))204                    {205                        return new { unserializableValue = "-Infinity" };206                    }207                    if (double.IsNaN(d))208                    {209                        return new { unserializableValue = "NaN" };210                    }211                    break;212                case JSHandle objectHandle:213                    return objectHandle.FormatArgument(this);214            }215            return new { value = arg };216        }217        private static string GetExceptionMessage(EvaluateExceptionDetails exceptionDetails)218        {219            if (exceptionDetails.Exception != null)220            {221                return exceptionDetails.Exception.Description ?? exceptionDetails.Exception.Value;222            }223            var message = exceptionDetails.Text;224            if (exceptionDetails.StackTrace != null)225            {226                foreach (var callframe in exceptionDetails.StackTrace.CallFrames)...

...255        {256            try257            {258                ElementHandle element = await mPage.QuerySelectorAsync(selector);259                JSHandle handler = await element.GetPropertyAsync("innerHTML");260                return handler.ToString().Replace("JSHandle:", string.Empty);261            }262            catch263            {264                return null;265            }266        }267        public async Task<string> GetElementInnerText(string selector)268        {269            try270            {271                ElementHandle element = await mPage.QuerySelectorAsync(selector);272                JSHandle handler = await element.GetPropertyAsync("innerText");273                return handler.ToString().Replace("JSHandle:", string.Empty);274            }275            catch276            {277                return null;278            }279        }280        public async Task<string[]> GetElementClassListAsynct(string selector)281        {282            try283            {284                ElementHandle element = await mPage.QuerySelectorAsync(selector);285                JSHandle handler = await element.GetPropertyAsync("classList");286                Dictionary<string, string> value = await handler.JsonValueAsync<Dictionary<string, string>>();287                string[] result = new string[value.Count];288                value.Values.CopyTo(result, 0);289                return result;290            }291            catch292            {293                return null;294            }295        }296        public async Task<string> GetElementClassStringAsync(string selector)297        {298            try299            {300                ElementHandle element = await mPage.QuerySelectorAsync(selector);301                JSHandle handler = await element.GetPropertyAsync("classList");302                object value = await handler.JsonValueAsync();303                return value.ToString();304            }305            catch306            {307                return null;308            }309        }310        public async Task<string> GetURLAsync(int times = 3, int delay = 3000)311        {312            do313            {314                try315                {...

...6using PuppeteerSharp.Messaging;7namespace PuppeteerSharp8{9    /// <summary>10    /// JSHandle represents an in-page JavaScript object. JSHandles can be created with the <see cref="Page.EvaluateExpressionHandleAsync(string)"/> and <see cref="Page.EvaluateFunctionHandleAsync(string, object[])"/> methods.11    /// </summary>12    public class JSHandle13    {14        internal JSHandle(ExecutionContext context, CDPSession client, JToken remoteObject)15        {16            ExecutionContext = context;17            Client = client;18            Logger = Client.Connection.LoggerFactory.CreateLogger(GetType());19            RemoteObject = remoteObject;20        }21        /// <summary>22        /// Gets the execution context.23        /// </summary>24        /// <value>The execution context.</value>25        public ExecutionContext ExecutionContext { get; }26        /// <summary>27        /// Gets or sets a value indicating whether this <see cref="JSHandle"/> is disposed.28        /// </summary>29        /// <value><c>true</c> if disposed; otherwise, <c>false</c>.</value>30        public bool Disposed { get; private set; }31        /// <summary>32        /// Gets or sets the remote object.33        /// </summary>34        /// <value>The remote object.</value>35        public JToken RemoteObject { get; }36        /// <summary>37        /// Gets the client.38        /// </summary>39        /// <value>The client.</value>40        protected CDPSession Client { get; }41        /// <summary>42        /// Gets the logger.43        /// </summary>44        /// <value>The logger.</value>45        protected ILogger Logger { get; }46        /// <summary>47        /// Fetches a single property from the referenced object48        /// </summary>49        /// <param name="propertyName">property to get</param>50        /// <returns>Task of <see cref="JSHandle"/></returns>51        public async Task<JSHandle> GetPropertyAsync(string propertyName)52        {53            var objectHandle = await ExecutionContext.EvaluateFunctionHandleAsync(@"(object, propertyName) => {54              const result = { __proto__: null};55              result[propertyName] = object[propertyName];56              return result;57            }", this, propertyName).ConfigureAwait(false);58            var properties = await objectHandle.GetPropertiesAsync().ConfigureAwait(false);59            properties.TryGetValue(propertyName, out var result);60            await objectHandle.DisposeAsync().ConfigureAwait(false);61            return result;62        }63        /// <summary>64        /// Returns a <see cref="Dictionary{TKey, TValue}"/> with property names as keys and <see cref="JSHandle"/> instances for the property values.65        /// </summary>66        /// <returns>Task which resolves to a <see cref="Dictionary{TKey, TValue}"/></returns>67        /// <example>68        /// <code>69        /// var handle = await page.EvaluateExpressionHandle("({window, document})");70        /// var properties = await handle.GetPropertiesAsync();71        /// var windowHandle = properties["window"];72        /// var documentHandle = properties["document"];73        /// await handle.DisposeAsync();74        /// </code>75        /// </example>76        public async Task<Dictionary<string, JSHandle>> GetPropertiesAsync()77        {78            var response = await Client.SendAsync("Runtime.getProperties", new79            {80                objectId = RemoteObject[MessageKeys.ObjectId].AsString(),81                ownProperties = true82            }).ConfigureAwait(false);83            var result = new Dictionary<string, JSHandle>();84            foreach (var property in response[MessageKeys.Result])85            {86                if (property[MessageKeys.Enumerable] == null)87                {88                    continue;89                }90                result.Add(property[MessageKeys.Name].AsString(), ExecutionContext.CreateJSHandle(property[MessageKeys.Value]));91            }92            return result;93        }94        /// <summary>95        /// Returns a JSON representation of the object96        /// </summary>97        /// <returns>Task</returns>98        /// <remarks>99        /// The method will return an empty JSON if the referenced object is not stringifiable. It will throw an error if the object has circular references100        /// </remarks>101        public async Task<object> JsonValueAsync() => await JsonValueAsync<object>().ConfigureAwait(false);102        /// <summary>103        /// Returns a JSON representation of the object104        /// </summary>105        /// <typeparam name="T">A strongly typed object to parse to</typeparam>106        /// <returns>Task</returns>107        /// <remarks>108        /// The method will return an empty JSON if the referenced object is not stringifiable. It will throw an error if the object has circular references109        /// </remarks>110        public async Task<T> JsonValueAsync<T>()111        {112            var objectId = RemoteObject[MessageKeys.ObjectId];113            if (objectId != null)114            {115                var response = await Client.SendAsync("Runtime.callFunctionOn", new Dictionary<string, object>116                {117                    ["functionDeclaration"] = "function() { return this; }",118                    [MessageKeys.ObjectId] = objectId,119                    ["returnByValue"] = true,120                    ["awaitPromise"] = true121                }).ConfigureAwait(false);122                return (T)RemoteObjectHelper.ValueFromRemoteObject<T>(response[MessageKeys.Result]);123            }124            return (T)RemoteObjectHelper.ValueFromRemoteObject<T>(RemoteObject);125        }126        /// <summary>127        /// Disposes the Handle. It will mark the JSHandle as disposed and release the <see cref="JSHandle.RemoteObject"/>128        /// </summary>129        /// <returns>The async.</returns>130        public async Task DisposeAsync()131        {132            if (Disposed)133            {134                return;135            }136            Disposed = true;137            await RemoteObjectHelper.ReleaseObject(Client, RemoteObject, Logger).ConfigureAwait(false);138        }139        /// <inheritdoc/>140        public override string ToString()141        {142            if ((RemoteObject)[MessageKeys.ObjectId] != null)143            {144                var type = RemoteObject[MessageKeys.Subtype] ?? RemoteObject[MessageKeys.Type];145                return "JSHandle@" + type;146            }147            return "JSHandle:" + RemoteObjectHelper.ValueFromRemoteObject<object>(RemoteObject)?.ToString();148        }149        internal object FormatArgument(ExecutionContext context)150        {151            if (ExecutionContext != context)152            {153                throw new PuppeteerException("JSHandles can be evaluated only in the context they were created!");154            }155            if (Disposed)156            {157                throw new PuppeteerException("JSHandle is disposed!");158            }159            var unserializableValue = RemoteObject[MessageKeys.UnserializableValue];160            if (unserializableValue != null)161            {162                return unserializableValue;163            }164            if (RemoteObject[MessageKeys.ObjectId] == null)165            {166                var value = RemoteObject[MessageKeys.Value];167                return new { value };168            }169            var objectId = RemoteObject[MessageKeys.ObjectId];170            return new { objectId };171        }...

...23    public class Worker24    {25        private readonly CDPSession _client;26        private ExecutionContext _executionContext;27        // private readonly Func<ConsoleType, JSHandle[], StackTrace, Task> _consoleAPICalled;28        private readonly Action<EvaluateExceptionResponseDetails> _exceptionThrown;29        private readonly TaskCompletionSource<ExecutionContext> _executionContextCallback;30        private Func<ExecutionContext, RemoteObject, JSHandle> _jsHandleFactory;31        internal Worker(32            CDPSession client,33            string url,34            Func<ConsoleType, JSHandle[], Task> consoleAPICalled,35            Action<EvaluateExceptionResponseDetails> exceptionThrown)36        {37            _client = client;38            Url = url;39            _exceptionThrown = exceptionThrown;40            _client.MessageReceived += OnMessageReceived;41            _executionContextCallback = new TaskCompletionSource<ExecutionContext>(TaskCreationOptions.RunContinuationsAsynchronously);42            _ = _client.SendAsync("Runtime.enable").ContinueWith(task =>43            {44            });45            _ = _client.SendAsync("Log.enable").ContinueWith(task =>46            {47            });48        }49        /// <summary>50        /// Gets the Worker URL.51        /// </summary>52        /// <value>Worker URL.</value>53        public string Url { get; }54        internal void OnMessageReceived(object sender, MessageEventArgs e)55        {56            try57            {58                switch (e.MessageID)59                {60                    case "Runtime.executionContextCreated":61                        OnExecutionContextCreated(e.MessageData.ToObject<RuntimeExecutionContextCreatedResponse>(true));62                        break;63                    //case "Runtime.consoleAPICalled":64                    //    await OnConsoleAPICalled(e).ConfigureAwait(false);65                    //    break;66                    case "Runtime.exceptionThrown":67                        OnExceptionThrown(e.MessageData.ToObject<RuntimeExceptionThrownResponse>(true));68                        break;69                }70            }71            catch (Exception ex)72            {73                var message = $"Worker failed to process {e.MessageID}. {ex.Message}. {ex.StackTrace}";74                _client.Close(message);75            }76        }77        private void OnExceptionThrown(RuntimeExceptionThrownResponse e) => _exceptionThrown(e.ExceptionDetails);78        private void OnExecutionContextCreated(RuntimeExecutionContextCreatedResponse e)79        {80            if (_jsHandleFactory == null)81            {82                _jsHandleFactory = (ctx, remoteObject) => new JSHandle(ctx, _client, remoteObject);83                _executionContext = new ExecutionContext(84                    _client,85                    e.Context,86                    null);87                _executionContextCallback.TrySetResult(_executionContext);88            }89        }90    }91}...

2using PuppeteerSharp.Tests.Attributes;3using PuppeteerSharp.Xunit;4using Xunit;5using Xunit.Abstractions;6namespace PuppeteerSharp.Tests.JSHandleTests7{8    [Collection(TestConstants.TestFixtureCollectionName)]9    public class AsElementTests : PuppeteerPageBaseTest10    {11        public AsElementTests(ITestOutputHelper output) : base(output)12        {13        }14        [PuppeteerTest("jshandle.spec.ts", "JSHandle.asElement", "should work")]15        [PuppeteerFact]16        public async Task ShouldWork()17        {18            var aHandle = await Page.EvaluateExpressionHandleAsync("document.body");19            var element = aHandle as ElementHandle;20            Assert.NotNull(element);21        }22        [PuppeteerTest("jshandle.spec.ts", "JSHandle.asElement", "should return null for non-elements")]23        [PuppeteerFact]24        public async Task ShouldReturnNullForNonElements()25        {26            var aHandle = await Page.EvaluateExpressionHandleAsync("2");27            var element = aHandle as ElementHandle;28            Assert.Null(element);29        }30        [PuppeteerTest("jshandle.spec.ts", "JSHandle.asElement", "should return ElementHandle for TextNodes")]31        [PuppeteerFact]32        public async Task ShouldReturnElementHandleForTextNodes()33        {34            await Page.SetContentAsync("<div>ee!</div>");35            var aHandle = await Page.EvaluateExpressionHandleAsync("document.querySelector('div').firstChild");36            var element = aHandle as ElementHandle;37            Assert.NotNull(element);38            Assert.True(await Page.EvaluateFunctionAsync<bool>("e => e.nodeType === HTMLElement.TEXT_NODE", element));39        }40    }41}...

1using System;2using System.Collections.Generic;3using System.Text;4using System.Threading.Tasks;5using PuppeteerSharp;6namespace WebScrappingBase.PuppeteerPrelude7{8    public static class PuppeteerExtensions9    {10        public static async Task UseProxyAuth(this Page page, string credentials)11        {12            var authStr = $"Basic {Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials))}";13            await page.SetExtraHttpHeadersAsync(new Dictionary<string, string>14            {15                ["Proxy-Authorization"] = authStr16            });17        }18        public static async Task TypeAsync(this Frame frame, string selector, string text)19        {20            await (await frame.QuerySelectorAsync(selector)).TypeAsync(text);21        }22        public static async Task ClickAsync(this Frame frame, string selector)23        {24            await (await frame.QuerySelectorAsync(selector)).ClickAsync();25        }26        public static async Task WaitForTruth(this Page page, string script, WaitForFunctionOptions opts = null)27        {28            var jsHandle = await page.WaitForExpressionAsync(script, opts);29            await jsHandle.DisposeAsync();30        }31        public static async Task WaitForDocumentInteractiveState(this Page page, int? timeout = null)32        {33            await page.WaitForTruth("document.readyState === 'interactive' || document.readyState === 'complete'", new WaitForFunctionOptions { Timeout = timeout ?? page.Browser.DefaultWaitForTimeout });34        }35    }36}...

1using System.Threading.Tasks;2using Xunit;3using Xunit.Abstractions;4namespace PuppeteerSharp.Tests.JSHandleTests5{6    [Collection("PuppeteerLoaderFixture collection")]7    public class ToStringTests : PuppeteerPageBaseTest8    {9        public ToStringTests(ITestOutputHelper output) : base(output)10        {11        }12        [Fact]13        public async Task ShouldWorkForPrimitives()14        {15            var numberHandle = await Page.EvaluateExpressionHandleAsync("2");16            Assert.Equal("JSHandle:2", numberHandle.ToString());17            var stringHandle = await Page.EvaluateExpressionHandleAsync("'a'");18            Assert.Equal("JSHandle:a", stringHandle.ToString());19        }20        [Fact]21        public async Task ShouldWorkForComplicatedObjects()22        {23            var aHandle = await Page.EvaluateExpressionHandleAsync("window");24            Assert.Equal("JSHandle@object", aHandle.ToString());25        }26    }27}...

1using PuppeteerSharp.Messaging;2namespace PuppeteerSharp3{4    /// <summary>5    /// Inherits from <see cref="JSHandle"/>. It represents an in-page DOM element. 6    /// ElementHandles can be created by <see cref="PuppeteerSharp.Page.QuerySelectorAsync(string)"/> or <see cref="PuppeteerSharp.Page.QuerySelectorAllAsync(string)"/>.7    /// </summary>8    public class ElementHandle : JSHandle9    {10        internal ElementHandle(11            ExecutionContext context,12            CDPSession client,13            RemoteObject remoteObject)14            : base(context, client, remoteObject) { }15    }16}...

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);9            using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions10            {11            }))12            using (var page = await browser.NewPageAsync())13            {14                var title = await page.EvaluateFunctionAsync<string>("() => document.title");15                Console.WriteLine(title);16            }17        }18    }19}20using System;21using System.Threading.Tasks;22using PuppeteerSharp;23{24    {25        static async Task Main(string[] args)26        {27            await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);28            using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions29            {30            }))31            using (var page = await browser.NewPageAsync())32            {33                var title = await page.EvaluateFunctionAsync<string>("() => document.title");34                Console.WriteLine(title);35            }36        }37    }38}39using System;40using System.Threading.Tasks;41using PuppeteerSharp;42{43    {44        static async Task Main(string[] args)45        {46            await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);47            using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions48            {49            }))50            using (var page = await browser.NewPageAsync())51            {52                var title = await page.EvaluateFunctionAsync<string>("() => document.title");53                Console.WriteLine(title);54            }55        }56    }57}58using System;59using System.Threading.Tasks;60using PuppeteerSharp;61{62    {63        static async Task Main(string[] args)64        {

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });9            var page = await browser.NewPageAsync();10            var inputElement = await page.QuerySelectorAsync("input[name='q']");11            var inputElementJSHandle = await inputElement.GetJSHandleAsync();12            var inputElementValueJSHandle = await inputElementJSHandle.GetPropertyAsync("value");13            var inputElementValue = await inputElementValueJSHandle.JsonValueAsync();14            Console.WriteLine(inputElementValue);15        }16    }17}18using PuppeteerSharp;19using System;20using System.Threading.Tasks;21{22    {23        static async Task Main(string[] args)24        {25            var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });26            var page = await browser.NewPageAsync();27            var inputElement = await page.QuerySelectorAsync("input[name='q']");28            var inputElementValue = await page.EvaluateExpressionAsync<string>("document.querySelector(\"input[name='q']\").value");29            Console.WriteLine(inputElementValue);30        }31    }32}

1var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });2var page = await browser.NewPageAsync();3var searchBox = await page.QuerySelectorAsync("input[name='q']");4await searchBox.TypeAsync("puppeteer-sharp");5await page.Keyboard.PressAsync("Enter");6await page.WaitForNavigationAsync();7await page.ScreenshotAsync("screenshot.png");8await browser.CloseAsync();9var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });10var page = await browser.NewPageAsync();11var searchBox = await page.QuerySelectorAsync("input[name='q']");12await searchBox.TypeAsync("puppeteer-sharp");13await page.Keyboard.PressAsync("Enter");14await page.WaitForNavigationAsync();15await page.ScreenshotAsync("screenshot.png");16await browser.CloseAsync();17var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });18var page = await browser.NewPageAsync();19var searchBox = await page.QuerySelectorAsync("input[name='q']");20await searchBox.TypeAsync("puppeteer-sharp");21await page.Keyboard.PressAsync("Enter");22await page.WaitForNavigationAsync();23await page.ScreenshotAsync("screenshot.png");24await browser.CloseAsync();25var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });26var page = await browser.NewPageAsync();27var searchBox = await page.QuerySelectorAsync("input[name='q']");28await searchBox.TypeAsync("puppeteer-sharp");29await page.Keyboard.PressAsync("Enter");30await page.WaitForNavigationAsync();31await page.ScreenshotAsync("screenshot.png");32await browser.CloseAsync();33var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });34var page = await browser.NewPageAsync();35await page.GoToAsync("

1using PuppeteerSharp;2using System.Net;3using System.IO;4using System.IO;5using System;6using System.Text;7using System.Threading.Tasks;8using System.Diagnostics;9using System.Collections.Generic;10using System.Collections.Generic;11using System.Text.RegularExpressions;12using System.Text.RegularExpressions;13using System.Text.RegularExpressions;14using System.Text.RegularExpressions;15using System.Text.RegularExpressions;16using System.Text.RegularExpressions;17using System.Text.RegularExpressions;18using System.Text.RegularExpressions;19using System.Text.RegularExpressions;20using System.Text.RegularExpressions;21using System.Text.RegularExpressions;22using System.Text.RegularExpressions;23using System.Text.RegularExpressions;24using System.Text.RegularExpressions;25using System.Text.RegularExpressions;26using System.Text.RegularExpressions;

1var jsHandle = await page.EvaluateFunctionHandleAsync("() => document.querySelector('input[name=userName]')");2var value = await jsHandle.JsonValueAsync();3await jsHandle.DisposeAsync();4await page.CloseAsync();5await browser.CloseAsync();6await browser.DisposeAsync();7var jsHandle = await page.EvaluateHandleAsync("() => document.querySelector('input[name=userName]')");8var value = await jsHandle.JsonValueAsync();9await jsHandle.DisposeAsync();10await page.CloseAsync();11await browser.CloseAsync();12await browser.DisposeAsync();

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            var options = new LaunchOptions { Headless = false };9            using (var browser = await Puppeteer.LaunchAsync(options))10            {11                using (var page = await browser.NewPageAsync())12                {13                    var title = await page.EvaluateExpressionAsync<string>("document.title");14                    Console.WriteLine(title);15                    await page.EvaluateExpressionAsync("document.title='Hello World'");16                    title = await page.EvaluateExpressionAsync<string>("document.title");17                    Console.WriteLine(title);18                }19            }20        }21    }22}23using System;24using System.Threading.Tasks;25using PuppeteerSharp;26{27    {28        static async Task Main(string[] args)29        {30            var options = new LaunchOptions { Headless = false };31            using (var browser = await Puppeteer.LaunchAsync(options))32            {33                using (var page = await browser.NewPageAsync())34                {35                    var title = await page.EvaluateExpressionAsync<string>("document.title");36                    Console.WriteLine(title);37                    await page.EvaluateExpressionAsync("document.title='Hello World'");38                    title = await page.EvaluateExpressionAsync<string>("document.title");39                    Console.WriteLine(title);

1using PuppeteerSharp;2var value = await jsHandle.JsonValueAsync();3await jsHandle.DisposeAsync();4await page.CloseAsync();5await browser.CloseAsync();6await browser.DisposeAsync();