Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use JSHandle class of PuppeteerSharp package

Best Puppeteer-sharp code snippet using PuppeteerSharp.JSHandle

ExecutionContext.cs

Source:ExecutionContext.cs

...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)...

PageCTL.cs

Source:PageCTL.cs

...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                {...

JSHandle.cs

Source:JSHandle.cs

...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        }...

Worker.cs

Source:Worker.cs

...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}...

AsElementTests.cs

Source:AsElementTests.cs

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}...

PuppeteerExtensions.cs

Source:PuppeteerExtensions.cs

1ï»¿using 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}...

ToStringTests.cs

Source:ToStringTests.cs

1ï»¿using 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}...

ElementHandle.cs

Source:ElementHandle.cs

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}...

JSHandle

Using AI Code Generation

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        {

JSHandle

Using AI Code Generation

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}

JSHandle

Using AI Code Generation

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("

JSHandle

Using AI Code Generation

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;

JSHandle

Using AI Code Generation

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

JSHandle

Using AI Code Generation

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

JSHandle

Using AI Code Generation

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

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.