Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use EvaluateExpressionHandleAsync method of PuppeteerSharp.Frame class

Best Puppeteer-sharp code snippet using PuppeteerSharp.Frame.EvaluateExpressionHandleAsync

Page.cs

Source:Page.cs

...329        /// <remarks>330        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.331        /// </remarks>332        /// <returns>Task which resolves to script return value</returns>333        public async Task<JSHandle> EvaluateExpressionHandleAsync(string script)334        {335            var context = await MainFrame.GetExecutionContextAsync().ConfigureAwait(false);336            return await context.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);337        }338        /// <summary>339        /// Executes a script in browser context340        /// </summary>341        /// <param name="pageFunction">Script to be evaluated in browser context</param>342        /// <param name="args">Function arguments</param>343        /// <remarks>344        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.345        /// <see cref="JSHandle"/> instances can be passed as arguments346        /// </remarks>347        /// <returns>Task which resolves to script return value</returns>348        public async Task<JSHandle> EvaluateFunctionHandleAsync(string pageFunction, params object[] args)349        {350            var context = await MainFrame.GetExecutionContextAsync().ConfigureAwait(false);...

Frame.cs

Source:Frame.cs

...192        /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>193        /// <seealso cref="Page.EvaluateFunctionAsync{T}(string, object[])"/>194        public Task<T> EvaluateFunctionAsync<T>(string script, params object[] args) => MainWorld.EvaluateFunctionAsync<T>(script, args);195        /// <summary>196        /// Passes an expression to the <see cref="ExecutionContext.EvaluateExpressionHandleAsync(string)"/>, returns a <see cref="Task"/>, then <see cref="ExecutionContext.EvaluateExpressionHandleAsync(string)"/> would wait for the <see cref="Task"/> to resolve and return its value.197        /// </summary>198        /// <example>199        /// <code>200        /// var frame = page.MainFrame;201        /// const handle = Page.MainFrame.EvaluateExpressionHandleAsync("1 + 2");202        /// </code>203        /// </example>204        /// <returns>Resolves to the return value of <paramref name="script"/></returns>205        /// <param name="script">Expression to be evaluated in the <seealso cref="ExecutionContext"/></param>206        public Task<JSHandle> EvaluateExpressionHandleAsync(string script) => MainWorld.EvaluateExpressionHandleAsync(script);207        /// <summary>208        /// Passes a function to the <see cref="ExecutionContext.EvaluateFunctionAsync(string, object[])"/>, returns a <see cref="Task"/>, then <see cref="ExecutionContext.EvaluateFunctionHandleAsync(string, object[])"/> would wait for the <see cref="Task"/> to resolve and return its value.209        /// </summary>210        /// <example>211        /// <code>212        /// var frame = page.MainFrame;213        /// const handle = Page.MainFrame.EvaluateFunctionHandleAsync("() => Promise.resolve(self)");214        /// return handle; // Handle for the global object.215        /// </code>216        /// <see cref="JSHandle"/> instances can be passed as arguments to the <see cref="ExecutionContext.EvaluateFunctionAsync(string, object[])"/>:217        /// 218        /// const handle = await Page.MainFrame.EvaluateExpressionHandleAsync("document.body");219        /// const resultHandle = await Page.MainFrame.EvaluateFunctionHandleAsync("body => body.innerHTML", handle);220        /// return await resultHandle.JsonValueAsync(); // prints body's innerHTML221        /// </example>222        /// <returns>Resolves to the return value of <paramref name="function"/></returns>223        /// <param name="function">Function to be evaluated in the <see cref="ExecutionContext"/></param>224        /// <param name="args">Arguments to pass to <paramref name="function"/></param>225        public Task<JSHandle> EvaluateFunctionHandleAsync(string function, params object[] args) => MainWorld.EvaluateFunctionHandleAsync(function, args);226        /// <summary>227        /// Gets the <see cref="ExecutionContext"/> associated with the frame.228        /// </summary>229        /// <returns><see cref="ExecutionContext"/> associated with the frame.</returns>230        public Task<ExecutionContext> GetExecutionContextAsync() => MainWorld.GetExecutionContextAsync();231        /// <summary>232        /// Waits for a selector to be added to the DOM...

DOMWorld.cs

Source:DOMWorld.cs

...55                throw new PuppeteerException($"Execution Context is not available in detached frame \"{Frame.Url}\"(are you trying to evaluate?)");56            }57            return _contextResolveTaskWrapper.Task;58        }59        internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)60        {61            var context = await GetExecutionContextAsync().ConfigureAwait(false);62            return await context.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);63        }64        internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params object[] args)65        {66            var context = await GetExecutionContextAsync().ConfigureAwait(false);67            return await context.EvaluateFunctionHandleAsync(script, args).ConfigureAwait(false);68        }69        internal async Task<T> EvaluateExpressionAsync<T>(string script)70        {71            var context = await GetExecutionContextAsync().ConfigureAwait(false);72            return await context.EvaluateExpressionAsync<T>(script).ConfigureAwait(false);73        }74        internal async Task<JToken> EvaluateExpressionAsync(string script)75        {76            var context = await GetExecutionContextAsync().ConfigureAwait(false);77            return await context.EvaluateExpressionAsync(script).ConfigureAwait(false);78        }79        internal async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)80        {81            var context = await GetExecutionContextAsync().ConfigureAwait(false);82            return await context.EvaluateFunctionAsync<T>(script, args).ConfigureAwait(false);83        }84        internal async Task<JToken> EvaluateFunctionAsync(string script, params object[] args)85        {86            var context = await GetExecutionContextAsync().ConfigureAwait(false);87            return await context.EvaluateFunctionAsync(script, args).ConfigureAwait(false);88        }89        internal Task<string> GetContentAsync() => EvaluateFunctionAsync<string>(@"() => {90                let retVal = '';91                if (document.doctype)92                    retVal = new XMLSerializer().serializeToString(document.doctype);93                if (document.documentElement)94                    retVal += document.documentElement.outerHTML;95                return retVal;96            }");97        internal async Task SetContentAsync(string html, NavigationOptions options = null)98        {99            var waitUntil = options?.WaitUntil ?? new[] { WaitUntilNavigation.Load };100            var timeout = options?.Timeout ?? _timeoutSettings.NavigationTimeout;101            // We rely upon the fact that document.open() will reset frame lifecycle with "init"102            // lifecycle event. @see https://crrev.com/608658103            await EvaluateFunctionAsync(@"html => {104                document.open();105                document.write(html);106                document.close();107            }", html).ConfigureAwait(false);108            using (var watcher = new LifecycleWatcher(_frameManager, Frame, waitUntil, timeout))109            {110                var watcherTask = await Task.WhenAny(111                    watcher.TimeoutOrTerminationTask,112                    watcher.LifecycleTask).ConfigureAwait(false);113                await watcherTask.ConfigureAwait(false);114            }115        }116        internal async Task<ElementHandle> AddScriptTagAsync(AddTagOptions options)117        {118            const string addScriptUrl = @"async function addScriptUrl(url, type) {119              const script = document.createElement('script');120              script.src = url;121              if(type)122                script.type = type;123              const promise = new Promise((res, rej) => {124                script.onload = res;125                script.onerror = rej;126              });127              document.head.appendChild(script);128              await promise;129              return script;130            }";131            const string addScriptContent = @"function addScriptContent(content, type = 'text/javascript') {132              const script = document.createElement('script');133              script.type = type;134              script.text = content;135              let error = null;136              script.onerror = e => error = e;137              document.head.appendChild(script);138              if (error)139                throw error;140              return script;141            }";142            async Task<ElementHandle> AddScriptTagPrivate(string script, string urlOrContent, string type)143            {144                var context = await GetExecutionContextAsync().ConfigureAwait(false);145                return (string.IsNullOrEmpty(type)146                        ? await context.EvaluateFunctionHandleAsync(script, urlOrContent).ConfigureAwait(false)147                        : await context.EvaluateFunctionHandleAsync(script, urlOrContent, type).ConfigureAwait(false)) as ElementHandle;148            }149            if (!string.IsNullOrEmpty(options.Url))150            {151                var url = options.Url;152                try153                {154                    return await AddScriptTagPrivate(addScriptUrl, url, options.Type).ConfigureAwait(false);155                }156                catch (PuppeteerException)157                {158                    throw new PuppeteerException($"Loading script from {url} failed");159                }160            }161            if (!string.IsNullOrEmpty(options.Path))162            {163                var contents = await AsyncFileHelper.ReadAllText(options.Path).ConfigureAwait(false);164                contents += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);165                return await AddScriptTagPrivate(addScriptContent, contents, options.Type).ConfigureAwait(false);166            }167            if (!string.IsNullOrEmpty(options.Content))168            {169                return await AddScriptTagPrivate(addScriptContent, options.Content, options.Type).ConfigureAwait(false);170            }171            throw new ArgumentException("Provide options with a `Url`, `Path` or `Content` property");172        }173        internal async Task<ElementHandle> AddStyleTagAsync(AddTagOptions options)174        {175            const string addStyleUrl = @"async function addStyleUrl(url) {176              const link = document.createElement('link');177              link.rel = 'stylesheet';178              link.href = url;179              const promise = new Promise((res, rej) => {180                link.onload = res;181                link.onerror = rej;182              });183              document.head.appendChild(link);184              await promise;185              return link;186            }";187            const string addStyleContent = @"async function addStyleContent(content) {188              const style = document.createElement('style');189              style.type = 'text/css';190              style.appendChild(document.createTextNode(content));191              const promise = new Promise((res, rej) => {192                style.onload = res;193                style.onerror = rej;194              });195              document.head.appendChild(style);196              await promise;197              return style;198            }";199            if (!string.IsNullOrEmpty(options.Url))200            {201                var url = options.Url;202                try203                {204                    var context = await GetExecutionContextAsync().ConfigureAwait(false);205                    return (await context.EvaluateFunctionHandleAsync(addStyleUrl, url).ConfigureAwait(false)) as ElementHandle;206                }207                catch (PuppeteerException)208                {209                    throw new PuppeteerException($"Loading style from {url} failed");210                }211            }212            if (!string.IsNullOrEmpty(options.Path))213            {214                var contents = await AsyncFileHelper.ReadAllText(options.Path).ConfigureAwait(false);215                contents += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);216                var context = await GetExecutionContextAsync().ConfigureAwait(false);217                return (await context.EvaluateFunctionHandleAsync(addStyleContent, contents).ConfigureAwait(false)) as ElementHandle;218            }219            if (!string.IsNullOrEmpty(options.Content))220            {221                var context = await GetExecutionContextAsync().ConfigureAwait(false);222                return (await context.EvaluateFunctionHandleAsync(addStyleContent, options.Content).ConfigureAwait(false)) as ElementHandle;223            }224            throw new ArgumentException("Provide options with a `Url`, `Path` or `Content` property");225        }226        internal Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)227            => WaitForSelectorOrXPathAsync(selector, false, options);228        internal Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)229            => WaitForSelectorOrXPathAsync(xpath, true, options);230        internal Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options, params object[] args)231            => new WaitTask(232                this,233                script,234                false,235                "function",236                options.Polling,237                options.PollingInterval,238                options.Timeout ?? _timeoutSettings.Timeout,239                args).Task;240        internal Task<JSHandle> WaitForExpressionAsync(string script, WaitForFunctionOptions options)241            => new WaitTask(242                this,243                script,244                true,245                "function",246                options.Polling,247                options.PollingInterval,248                options.Timeout ?? _timeoutSettings.Timeout).Task;249        internal Task<string> GetTitleAsync() => EvaluateExpressionAsync<string>("document.title");250        private async Task<ElementHandle> GetDocument()251        {252            if (_documentCompletionSource == null)253            {254                _documentCompletionSource = new TaskCompletionSource<ElementHandle>(TaskCreationOptions.RunContinuationsAsynchronously);255                var context = await GetExecutionContextAsync().ConfigureAwait(false);256                var document = await context.EvaluateExpressionHandleAsync("document").ConfigureAwait(false);257                _documentCompletionSource.TrySetResult(document as ElementHandle);258            }259            return await _documentCompletionSource.Task.ConfigureAwait(false);260        }261        private async Task<ElementHandle> WaitForSelectorOrXPathAsync(string selectorOrXPath, bool isXPath, WaitForSelectorOptions options = null)262        {263            options = options ?? new WaitForSelectorOptions();264            var timeout = options.Timeout ?? _timeoutSettings.Timeout;265            const string predicate = @"266              function predicate(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {267                const node = isXPath268                  ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue269                  : document.querySelector(selectorOrXPath);270                if (!node)...

ExecutionContext.cs

Source:ExecutionContext.cs

...42        /// <remarks>43        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.44        /// </remarks>45        /// <seealso cref="EvaluateFunctionAsync{T}(string, object[])"/>46        /// <seealso cref="EvaluateExpressionHandleAsync(string)"/>47        /// <returns>Task which resolves to script return value</returns>48        public Task<JToken> EvaluateExpressionAsync(string script)49            => EvaluateAsync<JToken>(EvaluateExpressionHandleAsync(script));50        /// <summary>51        /// Executes a script in browser context52        /// </summary>53        /// <typeparam name="T">The type to deserialize the result to</typeparam>54        /// <param name="script">Script to be evaluated in browser context</param>55        /// <remarks>56        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.57        /// </remarks>58        /// <seealso cref="EvaluateFunctionAsync{T}(string, object[])"/>59        /// <seealso cref="EvaluateExpressionHandleAsync(string)"/>60        /// <returns>Task which resolves to script return value</returns>61        public Task<T> EvaluateExpressionAsync<T>(string script)62            => EvaluateAsync<T>(EvaluateExpressionHandleAsync(script));63        /// <summary>64        /// Executes a function in browser context65        /// </summary>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"] = true...

NetworkEventTests.cs

Source:NetworkEventTests.cs

...34            await Page.GoToAsync(TestConstants.EmptyPage);35            Server.SetRoute("/post", context => Task.CompletedTask);36            Request request = null;37            Page.Request += (sender, e) => request = e.Request;38            await Page.EvaluateExpressionHandleAsync("fetch('./post', { method: 'POST', body: JSON.stringify({ foo: 'bar'})})");39            Assert.NotNull(request);40            Assert.Equal("{\"foo\":\"bar\"}", request.PostData);41        }42        [Fact]43        public async Task PageEventsResponse()44        {45            var responses = new List<Response>();46            Page.Response += (sender, e) => responses.Add(e.Response);47            await Page.GoToAsync(TestConstants.EmptyPage);48            Assert.Single(responses);49            Assert.Equal(TestConstants.EmptyPage, responses[0].Url);50            Assert.Equal(HttpStatusCode.OK, responses[0].Status);51            Assert.NotNull(responses[0].Request);52        }...

EvaluateTests.cs

Source:EvaluateTests.cs

...129        }130        [Fact]131        public async Task ShouldAcceptObjectHandleAsAnArgument()132        {133            var navigatorHandle = await Page.EvaluateExpressionHandleAsync("navigator");134            var text = await Page.EvaluateFunctionAsync<string>("e => e.userAgent", navigatorHandle);135            Assert.Contains("Mozilla", text);136        }137        [Fact]138        public async Task ShouldAcceptObjectHandleToPrimitiveTypes()139        {140            var aHandle = await Page.EvaluateExpressionHandleAsync("5");141            var isFive = await Page.EvaluateFunctionAsync<bool>("e => Object.is(e, 5)", aHandle);142            Assert.True(isFive);143        }144        [Fact]145        public async Task ShouldWorkFromInsideAnExposedFunction()146        {147            await Page.ExposeFunctionAsync("callController", async (int a, int b) =>148            {149                return await Page.EvaluateFunctionAsync("(a, b) => a * b", a, b);150            });151            var result = await Page.EvaluateFunctionAsync<int>(@"async function() {152                return await callController(9, 3);153            }");154            Assert.Equal(27, result);...

PuppeteerExtensions.cs

Source:PuppeteerExtensions.cs

...7		#region Methods8		public static async Task<ElementHandle> QuerySelectorByXPath(this Page page, string xpath)9		{10			var script = $"document.evaluate('{xpath}', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;";11			var handle = await page.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);12			if (handle is ElementHandle element)13			{14				return element;15			}16			await handle.DisposeAsync().ConfigureAwait(false);17			return null;18		}19		20		public static async Task<ElementHandle> QuerySelectorByXPath(this Frame frame, string xpath)21		{22			var script = $"document.evaluate('{xpath}', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;";23			var handle = await frame.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);24			if (handle is ElementHandle element)25			{26				return element;27			}28			await handle.DisposeAsync().ConfigureAwait(false);29			return null;30		}31		#endregion32	}33}...

EvaluateHandleTests.cs

Source:EvaluateHandleTests.cs

...16        [PuppeteerFact]17        public async Task ShouldWork()18        {19            await Page.GoToAsync(TestConstants.EmptyPage);20            var windowHandle = await Page.MainFrame.EvaluateExpressionHandleAsync("window");21            Assert.NotNull(windowHandle);22        }23    }24}...

EvaluateExpressionHandleAsync

Using AI Code Generation

1public static async Task EvaluateExpressionHandleAsyncExample()2{3    var options = new LaunchOptions { Headless = false };4    using (var browser = await Puppeteer.LaunchAsync(options))5    using (var page = await browser.NewPageAsync())6    {7        var elementHandle = await page.EvaluateExpressionHandleAsync("document");8        Console.WriteLine(elementHandle);9    }10}11public static async Task EvaluateFunctionHandleAsyncExample()12{13    var options = new LaunchOptions { Headless = false };14    using (var browser = await Puppeteer.LaunchAsync(options))15    using (var page = await browser.NewPageAsync())16    {17        var elementHandle = await page.EvaluateFunctionHandleAsync("() => document");18        Console.WriteLine(elementHandle);19    }20}21public static async Task EvaluateFunctionHandleAsyncExample()22{23    var options = new LaunchOptions { Headless = false };24    using (var browser = await Puppeteer.LaunchAsync(options))25    using (var page = await browser.NewPageAsync())26    {27        var elementHandle = await page.EvaluateFunctionHandleAsync("function() { return document; }");28        Console.WriteLine(elementHandle);29    }30}31public static async Task EvaluateFunctionHandleAsyncExample()32{33    var options = new LaunchOptions { Headless = false };34    using (var browser = await Puppeteer.LaunchAsync(options))35    using (var page = await browser.NewPageAsync())36    {37        var elementHandle = await page.EvaluateFunctionHandleAsync("() => { return document; }");38        Console.WriteLine(elementHandle);39    }40}41public static async Task EvaluateFunctionHandleAsyncExample()42{43    var options = new LaunchOptions { Headless = false };44    using (var browser = await Puppeteer.LaunchAsync(options))

EvaluateExpressionHandleAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static void Main(string[] args)7        {8            MainAsync().Wait();9        }10        static async Task MainAsync()11        {12            {13            };14            var browser = await Puppeteer.LaunchAsync(options);15            var page = await browser.NewPageAsync();16            await page.WaitForSelectorAsync("input[name='q']");17            var handle = await page.EvaluateExpressionHandleAsync("document");18            Console.WriteLine(handle);19            await browser.CloseAsync();20        }21    }22}23using System;24using System.Threading.Tasks;25using PuppeteerSharp;26{27    {28        static void Main(string[] args)29        {30            MainAsync().Wait();31        }32        static async Task MainAsync()33        {34            {35            };36            var browser = await Puppeteer.LaunchAsync(options);37            var page = await browser.NewPageAsync();38            await page.WaitForSelectorAsync("input[name='q']");39            var handle = await page.EvaluateExpressionHandleAsync("document.querySelector('input')");40            Console.WriteLine(handle);41            await browser.CloseAsync();42        }43    }44}

EvaluateExpressionHandleAsync

Using AI Code Generation

1var page = await browser.NewPageAsync();2var handle = await page.EvaluateExpressionHandleAsync("document.body");3var properties = await handle.GetPropertiesAsync();4var values = await Task.WhenAll(properties.Values.Select(x => x.JsonValueAsync()));5foreach (var value in values)6{7    Console.WriteLine(value);8}9await browser.CloseAsync();10var page = await browser.NewPageAsync();11var handle = await page.EvaluateExpressionHandleAsync("document.body");12var properties = await handle.GetPropertiesAsync();13var values = await Task.WhenAll(properties.Values.Select(x => x.JsonValueAsync()));14foreach (var value in values)15{16    Console.WriteLine(value);17}18await browser.CloseAsync();19var page = await browser.NewPageAsync();20var handle = await page.EvaluateExpressionHandleAsync("document.body");21var properties = await handle.GetPropertiesAsync();22var values = await Task.WhenAll(properties.Values.Select(x => x.JsonValueAsync()));23foreach (var value in values)24{25    Console.WriteLine(value);26}27await browser.CloseAsync();28var page = await browser.NewPageAsync();29var handle = await page.EvaluateExpressionHandleAsync("document.body");30var properties = await handle.GetPropertiesAsync();31var values = await Task.WhenAll(properties.Values.Select(x => x.JsonValueAsync()));32foreach (var value in values)33{34    Console.WriteLine(value);35}36await browser.CloseAsync();37var page = await browser.NewPageAsync();38var handle = await page.EvaluateExpressionHandleAsync("document.body");39var properties = await handle.GetPropertiesAsync();40var values = await Task.WhenAll(properties.Values.Select(x => x.JsonValueAsync()));41foreach (var value in values)42{43    Console.WriteLine(value);44}45await browser.CloseAsync();

EvaluateExpressionHandleAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            {9            };10            using (var browser = await Puppeteer.LaunchAsync(options))11            using (var page = await browser.NewPageAsync())12            {13                var expression = "document.querySelector('p')";14                var handle = await page.MainFrame.EvaluateExpressionHandleAsync(expression);15                Console.WriteLine(handle);16            }17        }18    }19}20using System;21using System.Threading.Tasks;22using PuppeteerSharp;23{24    {25        static async Task Main(string[] args)26        {27            {28            };29            using (var browser = await Puppeteer.LaunchAsync(options))30            using (var page = await browser.NewPageAsync())31            {32                var expression = "document.querySelector('p')";33                var handle = await page.MainFrame.EvaluateExpressionHandleAsync(expression);34                var result = await handle.JsonValueAsync();35                Console.WriteLine(result);36            }37        }38    }39}40using System;41using System.Threading.Tasks;42using PuppeteerSharp;43{44    {45        static async Task Main(string[] args)46        {47            {48            };49            using (var browser = await Puppeteer.LaunchAsync(options))50            using (var page = await browser.NewPageAsync())51            {

EvaluateExpressionHandleAsync

Using AI Code Generation

1var frame = await page.GetMainFrameAsync();2var handle = await frame.EvaluateExpressionHandleAsync("document.querySelector('div')");3var element = (ElementHandle)handle;4var result = await element.EvaluateFunctionAsync<string>("element => element.nodeName");5Console.WriteLine(result);6var frame = await page.GetMainFrameAsync();7var handle = await page.EvaluateExpressionHandleAsync("document.querySelector('div')");8var element = (ElementHandle)handle;9var result = await element.EvaluateFunctionAsync<string>("element => element.nodeName");10Console.WriteLine(result);11Your name to display (optional):12Your name to display (optional):13var frame = await page.GetMainFrameAsync();14var handle = await frame.EvaluateExpressionHandleAsync("document.querySelector('div')");15var element = (ElementHandle)handle;16var result = await element.EvaluateFunctionAsync<string>("element => element.nodeName");17Console.WriteLine(result);18Your name to display (optional):

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.