How to use FrameManager class of PuppeteerSharp package

Best Puppeteer-sharp code snippet using PuppeteerSharp.FrameManager

Page.cs

Source:Page.cs

...219        /// </summary>220        /// <remarks>221        /// Page is guaranteed to have a main frame which persists during navigations.222        /// </remarks>223        public Frame MainFrame => FrameManager.MainFrame;224        /// <summary>225        /// Gets all frames attached to the page.226        /// </summary>227        /// <value>An array of all frames attached to the page.</value>228        public Frame[] Frames => FrameManager.GetFrames();229        ///// <summary>230        ///// Gets all workers in the page.231        ///// </summary>232        //public Worker[] Workers => _workers.Values.ToArray();233        /// <summary>234        /// Shortcut for <c>page.MainFrame.Url</c>235        /// </summary>236        public string Url => MainFrame.Url;237        /// <summary>238        /// Gets that target this page was created from.239        /// </summary>240        public Target Target { get; }241        /// <summary>242        /// Gets this page's keyboard243        /// </summary>244        public Keyboard Keyboard { get; }245        /// <summary>246        /// Gets this page's touchscreen247        /// </summary>248        public Touchscreen Touchscreen { get; }249        /// <summary>250        /// Gets this page's coverage251        /// </summary>252        public Coverage Coverage { get; }253        /// <summary>254        /// Gets this page's mouse255        /// </summary>256        public Mouse Mouse { get; }257        /// <summary>258        /// Gets this page's viewport259        /// </summary>260        public ViewPortOptions Viewport { get; private set; }261        /// <summary>262        /// List of supported metrics provided by the <see cref="Metrics"/> event.263        /// </summary>264        public static readonly IEnumerable<string> SupportedMetrics = new List<string>265        {266            "Timestamp",267            "Documents",268            "Frames",269            "JSEventListeners",270            "Nodes",271            "LayoutCount",272            "RecalcStyleCount",273            "LayoutDuration",274            "RecalcStyleDuration",275            "ScriptDuration",276            "TaskDuration",277            "JSHeapUsedSize",278            "JSHeapTotalSize"279        };280        /// <summary>281        /// Get the browser the page belongs to.282        /// </summary>283        public Browser Browser => Target.Browser;284        /// <summary>285        /// Get the browser context that the page belongs to.286        /// </summary>287        public BrowserContext BrowserContext => Target.BrowserContext;288        /// <summary>289        /// Get an indication that the page has been closed.290        /// </summary>291        public bool IsClosed { get; private set; }292        /// <summary>293        /// Gets the accessibility.294        /// </summary>295        public Accessibility Accessibility { get; }296        internal bool JavascriptEnabled { get; set; } = true;297        internal bool HasPopupEventListeners => Popup?.GetInvocationList().Any() == true;298        internal FrameManager FrameManager { get; private set; }299        private Task SessionClosedTask300        {301            get302            {303                if (_sessionClosedTcs == null)304                {305                    _sessionClosedTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);306                    Client.Disconnected += clientDisconnected;307                    void clientDisconnected(object sender, EventArgs e)308                    {309                        _sessionClosedTcs.TrySetException(new TargetClosedException("Target closed", "Session closed"));310                        Client.Disconnected -= clientDisconnected;311                    }312                }313                return _sessionClosedTcs.Task;314            }315        }316        #endregion317        #region Public Methods318        /// <summary>319        /// A utility function to be used with <see cref="Extensions.EvaluateFunctionAsync{T}(Task{JSHandle}, string, object[])"/>320        /// </summary>321        /// <param name="selector">A selector to query page for</param>322        /// <returns>Task which resolves to a <see cref="JSHandle"/> of <c>document.querySelectorAll</c> result</returns>323        public Task<JSHandle> QuerySelectorAllHandleAsync(string selector)324            => EvaluateFunctionHandleAsync("selector => Array.from(document.querySelectorAll(selector))", selector);325        /// <summary>326        /// Executes a script in browser context327        /// </summary>328        /// <param name="script">Script to be evaluated in browser context</param>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);351            return await context.EvaluateFunctionHandleAsync(pageFunction, args).ConfigureAwait(false);352        }353        /// <summary>354        /// Activating request interception enables <see cref="Request.AbortAsync(RequestAbortErrorCode)">request.AbortAsync</see>, 355        /// <see cref="Request.ContinueAsync(Payload)">request.ContinueAsync</see> and <see cref="Request.RespondAsync(ResponseData)">request.RespondAsync</see> methods.356        /// </summary>357        /// <returns>The request interception task.</returns>358        /// <param name="value">Whether to enable request interception..</param>359        public Task SetRequestInterceptionAsync(bool value)360            => FrameManager.NetworkManager.SetRequestInterceptionAsync(value);361        /// <summary>362        /// Set offline mode for the page.363        /// </summary>364        /// <returns>Result task</returns>365        /// <param name="value">When <c>true</c> enables offline mode for the page.</param>366        public Task SetOfflineModeAsync(bool value) => FrameManager.NetworkManager.SetOfflineModeAsync(value);367        /// <summary>368        /// Adds a <c><![CDATA[<script>]]></c> tag into the page with the desired url or content369        /// </summary>370        /// <param name="options">add script tag options</param>371        /// <remarks>372        /// Shortcut for <c>page.MainFrame.AddScriptTagAsync(options)</c>373        /// </remarks>374        /// <returns>Task which resolves to the added tag when the script's onload fires or when the script content was injected into frame</returns>375        /// <seealso cref="Frame.AddScriptTagAsync(AddTagOptions)"/>376        public Task<ElementHandle> AddScriptTagAsync(AddTagOptions options) => MainFrame.AddScriptTagAsync(options);377        /// <summary>378        /// Adds a <c><![CDATA[<script>]]></c> tag into the page with the desired url or content379        /// </summary>380        /// <param name="url">script url</param>381        /// <remarks>382        /// Shortcut for <c>page.MainFrame.AddScriptTagAsync(new AddTagOptions { Url = url })</c>383        /// </remarks>384        /// <returns>Task which resolves to the added tag when the script's onload fires or when the script content was injected into frame</returns>385        public Task<ElementHandle> AddScriptTagAsync(string url) => AddScriptTagAsync(new AddTagOptions { Url = url });386        /// <summary>387        /// Adds a <c><![CDATA[<link rel="stylesheet">]]></c> tag into the page with the desired url or a <c><![CDATA[<link rel="stylesheet">]]></c> tag with the content388        /// </summary>389        /// <param name="options">add style tag options</param>390        /// <remarks>391        /// Shortcut for <c>page.MainFrame.AddStyleTagAsync(options)</c>392        /// </remarks>393        /// <returns>Task which resolves to the added tag when the stylesheet's onload fires or when the CSS content was injected into frame</returns>394        /// <seealso cref="Frame.AddStyleTag(AddTagOptions)"/>395        public Task<ElementHandle> AddStyleTagAsync(AddTagOptions options) => MainFrame.AddStyleTagAsync(options);396        /// <summary>397        /// Adds a <c><![CDATA[<link rel="stylesheet">]]></c> tag into the page with the desired url or a <c><![CDATA[<link rel="stylesheet">]]></c> tag with the content398        /// </summary>399        /// <param name="url">stylesheel url</param>400        /// <remarks>401        /// Shortcut for <c>page.MainFrame.AddStyleTagAsync(new AddTagOptions { Url = url })</c>402        /// </remarks>403        /// <returns>Task which resolves to the added tag when the stylesheet's onload fires or when the CSS content was injected into frame</returns>404        public Task<ElementHandle> AddStyleTagAsync(string url) => AddStyleTagAsync(new AddTagOptions { Url = url });405        /// <summary>406        /// Adds a function called <c>name</c> on the page's <c>window</c> object.407        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves when <paramref name="puppeteerFunction"/> completes.408        /// </summary>409        /// <param name="name">Name of the function on the window object</param>410        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>411        /// <remarks>412        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.413        /// Functions installed via <see cref="ExposeFunctionAsync(string, Action)"/> survive navigations414        /// </remarks>415        /// <returns>Task</returns>416        public Task ExposeFunctionAsync(string name, Action puppeteerFunction)417            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);418        /// <summary>419        /// Adds a function called <c>name</c> on the page's <c>window</c> object.420        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.421        /// </summary>422        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>423        /// <param name="name">Name of the function on the window object</param>424        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>425        /// <remarks>426        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.427        /// Functions installed via <see cref="ExposeFunctionAsync{TResult}(string, Func{TResult})"/> survive navigations428        /// </remarks>429        /// <returns>Task</returns>430        public Task ExposeFunctionAsync<TResult>(string name, Func<TResult> puppeteerFunction)431            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);432        /// <summary>433        /// Adds a function called <c>name</c> on the page's <c>window</c> object.434        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.435        /// </summary>436        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>437        /// <typeparam name="T">The parameter of <paramref name="puppeteerFunction"/></typeparam>438        /// <param name="name">Name of the function on the window object</param>439        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>440        /// <remarks>441        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.442        /// Functions installed via <see cref="ExposeFunctionAsync{T, TResult}(string, Func{T, TResult})"/> survive navigations443        /// </remarks>444        /// <returns>Task</returns>445        public Task ExposeFunctionAsync<T, TResult>(string name, Func<T, TResult> puppeteerFunction)446            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);447        /// <summary>448        /// Adds a function called <c>name</c> on the page's <c>window</c> object.449        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.450        /// </summary>451        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>452        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>453        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>454        /// <param name="name">Name of the function on the window object</param>455        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>456        /// <remarks>457        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.458        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, TResult}(string, Func{T1, T2, TResult})"/> survive navigations459        /// </remarks>460        /// <returns>Task</returns>461        public Task ExposeFunctionAsync<T1, T2, TResult>(string name, Func<T1, T2, TResult> puppeteerFunction)462            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);463        /// <summary>464        /// Adds a function called <c>name</c> on the page's <c>window</c> object.465        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.466        /// </summary>467        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>468        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>469        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>470        /// <typeparam name="T3">The third parameter of <paramref name="puppeteerFunction"/></typeparam>471        /// <param name="name">Name of the function on the window object</param>472        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>473        /// <remarks>474        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.475        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, T3, TResult}(string, Func{T1, T2, T3, TResult})"/> survive navigations476        /// </remarks>477        /// <returns>Task</returns>478        public Task ExposeFunctionAsync<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> puppeteerFunction)479            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);480        /// <summary>481        /// Adds a function called <c>name</c> on the page's <c>window</c> object.482        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.483        /// </summary>484        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>485        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>486        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>487        /// <typeparam name="T3">The third parameter of <paramref name="puppeteerFunction"/></typeparam>488        /// <typeparam name="T4">The fourth parameter of <paramref name="puppeteerFunction"/></typeparam>489        /// <param name="name">Name of the function on the window object</param>490        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>491        /// <remarks>492        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.493        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, T3, T4, TResult}(string, Func{T1, T2, T3, T4, TResult})"/> survive navigations494        /// </remarks>495        /// <returns>Task</returns>496        public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> puppeteerFunction)497            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);498        /// <summary>499        /// Gets the full HTML contents of the page, including the doctype.500        /// </summary>501        /// <returns>Task which resolves to the HTML content.</returns>502        /// <seealso cref="Frame.GetContentAsync"/>503        public Task<string> GetContentAsync() => FrameManager.MainFrame.GetContentAsync();504        /// <summary>505        /// Sets the HTML markup to the page506        /// </summary>507        /// <param name="html">HTML markup to assign to the page.</param>508        /// <param name="options">The navigations options</param>509        /// <returns>Task.</returns>510        /// <seealso cref="Frame.SetContentAsync(string, NavigationOptions)"/>511        public Task SetContentAsync(string html, NavigationOptions options = null) => FrameManager.MainFrame.SetContentAsync(html, options);512        /// <summary>513        /// Navigates to an url514        /// </summary>515        /// <remarks>516        /// <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> will throw an error if:517        /// - there's an SSL error (e.g. in case of self-signed certificates).518        /// - target URL is invalid.519        /// - the `timeout` is exceeded during navigation.520        /// - the remote server does not respond or is unreachable.521        /// - the main resource failed to load.522        /// 523        /// <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> will not throw an error when any valid HTTP status code is returned by the remote server, 524        /// including 404 "Not Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling <see cref="Response.Status"/>525        /// 526        /// > **NOTE** <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> either throws an error or returns a main resource response. 527        /// The only exceptions are navigation to `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.528        /// 529        /// > **NOTE** Headless mode doesn't support navigation to a PDF document. See the <see fref="https://bugs.chromium.org/p/chromium/issues/detail?id=761295">upstream issue</see>.530        /// 531        /// Shortcut for <seealso cref="Frame.GoToAsync(string, int?, WaitUntilNavigation[])"/>532        /// </remarks>533        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>534        /// <param name="options">Navigation parameters.</param>535        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect.</returns>536        /// <seealso cref="GoToAsync(string, int?, WaitUntilNavigation[])"/>537        public Task<Response> GoToAsync(string url, NavigationOptions options) => FrameManager.MainFrame.GoToAsync(url, options);538        /// <summary>539        /// Navigates to an url540        /// </summary>541        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>542        /// <param name="timeout">Maximum navigation time in milliseconds, defaults to 30 seconds, pass <c>0</c> to disable timeout. </param>543        /// <param name="waitUntil">When to consider navigation succeeded, defaults to <see cref="WaitUntilNavigation.Load"/>. Given an array of <see cref="WaitUntilNavigation"/>, navigation is considered to be successful after all events have been fired</param>544        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>545        /// <seealso cref="GoToAsync(string, NavigationOptions)"/>546        public Task<Response> GoToAsync(string url, int? timeout = null, WaitUntilNavigation[] waitUntil = null)547            => GoToAsync(url, new NavigationOptions { Timeout = timeout, WaitUntil = waitUntil });548        /// <summary>549        /// Navigates to an url550        /// </summary>551        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>552        /// <param name="waitUntil">When to consider navigation succeeded.</param>553        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>554        /// <seealso cref="GoToAsync(string, NavigationOptions)"/>555        public Task<Response> GoToAsync(string url, WaitUntilNavigation waitUntil)556            => GoToAsync(url, new NavigationOptions { WaitUntil = new[] { waitUntil } });557        /// <summary>558        /// generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>559        /// </summary>560        /// <param name="file">The file path to save the PDF to. paths are resolved using <see cref="Path.GetFullPath(string)"/></param>561        /// <returns></returns>562        /// <remarks>563        /// Generating a pdf is currently only supported in Chrome headless564        /// </remarks>565        public Task PdfAsync(string file) => PdfAsync(file, new PdfOptions());566        /// <summary>567        ///  generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>568        /// </summary>569        /// <param name="file">The file path to save the PDF to. paths are resolved using <see cref="Path.GetFullPath(string)"/></param>570        /// <param name="options">pdf options</param>571        /// <returns></returns>572        /// <remarks>573        /// Generating a pdf is currently only supported in Chrome headless574        /// </remarks>575        public async Task PdfAsync(string file, PdfOptions options)576            => await PdfInternalAsync(file, options).ConfigureAwait(false);577        /// <summary>578        /// generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>579        /// </summary>580        /// <returns>Task which resolves to a <see cref="Stream"/> containing the PDF data.</returns>581        /// <remarks>582        /// Generating a pdf is currently only supported in Chrome headless583        /// </remarks>584        public Task<Stream> PdfStreamAsync() => PdfStreamAsync(new PdfOptions());585        /// <summary>586        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>587        /// </summary>588        /// <param name="options">pdf options</param>589        /// <returns>Task which resolves to a <see cref="Stream"/> containing the PDF data.</returns>590        /// <remarks>591        /// Generating a pdf is currently only supported in Chrome headless592        /// </remarks>593        public async Task<Stream> PdfStreamAsync(PdfOptions options)594            => new MemoryStream(await PdfDataAsync(options).ConfigureAwait(false));595        /// <summary>596        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>597        /// </summary>598        /// <returns>Task which resolves to a <see cref="byte"/>[] containing the PDF data.</returns>599        /// <remarks>600        /// Generating a pdf is currently only supported in Chrome headless601        /// </remarks>602        public Task<byte[]> PdfDataAsync() => PdfDataAsync(new PdfOptions());603        /// <summary>604        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>605        /// </summary>606        /// <param name="options">pdf options</param>607        /// <returns>Task which resolves to a <see cref="byte"/>[] containing the PDF data.</returns>608        /// <remarks>609        /// Generating a pdf is currently only supported in Chrome headless610        /// </remarks>611        public Task<byte[]> PdfDataAsync(PdfOptions options) => PdfInternalAsync(null, options);612        internal async Task<byte[]> PdfInternalAsync(string file, PdfOptions options)613        {614            var paperWidth = PaperFormat.Letter.Width;615            var paperHeight = PaperFormat.Letter.Height;616            if (options.Format != null)617            {618                paperWidth = options.Format.Width;619                paperHeight = options.Format.Height;620            }621            else622            {623                if (options.Width != null)624                {625                    paperWidth = ConvertPrintParameterToInches(options.Width);626                }627                if (options.Height != null)628                {629                    paperHeight = ConvertPrintParameterToInches(options.Height);630                }631            }632            var marginTop = ConvertPrintParameterToInches(options.MarginOptions.Top);633            var marginLeft = ConvertPrintParameterToInches(options.MarginOptions.Left);634            var marginBottom = ConvertPrintParameterToInches(options.MarginOptions.Bottom);635            var marginRight = ConvertPrintParameterToInches(options.MarginOptions.Right);636            var result = await Client.SendAsync<PagePrintToPDFResponse>("Page.printToPDF", new PagePrintToPDFRequest637            {638                TransferMode = "ReturnAsStream",639                Landscape = options.Landscape,640                DisplayHeaderFooter = options.DisplayHeaderFooter,641                HeaderTemplate = options.HeaderTemplate,642                FooterTemplate = options.FooterTemplate,643                PrintBackground = options.PrintBackground,644                Scale = options.Scale,645                PaperWidth = paperWidth,646                PaperHeight = paperHeight,647                MarginTop = marginTop,648                MarginBottom = marginBottom,649                MarginLeft = marginLeft,650                MarginRight = marginRight,651                PageRanges = options.PageRanges,652                PreferCSSPageSize = options.PreferCSSPageSize653            }).ConfigureAwait(false);654            return await ProtocolStreamReader.ReadProtocolStreamByteAsync(Client, result.Stream, file).ConfigureAwait(false);655        }656        /// <summary>657        /// Enables/Disables Javascript on the page658        /// </summary>659        /// <returns>Task.</returns>660        /// <param name="enabled">Whether or not to enable JavaScript on the page.</param>661        public Task SetJavaScriptEnabledAsync(bool enabled)662        {663            if (enabled == JavascriptEnabled)664            {665                return Task.CompletedTask;666            }667            JavascriptEnabled = enabled;668            return Client.SendAsync("Emulation.setScriptExecutionDisabled", new EmulationSetScriptExecutionDisabledRequest669            {670                Value = !enabled671            });672        }673        /// <summary>674        /// Toggles bypassing page's Content-Security-Policy.675        /// </summary>676        /// <param name="enabled">sets bypassing of page's Content-Security-Policy.</param>677        /// <returns></returns>678        /// <remarks>679        /// CSP bypassing happens at the moment of CSP initialization rather then evaluation.680        /// Usually this means that <see cref="SetBypassCSPAsync(bool)"/> should be called before navigating to the domain.681        /// </remarks>682        public Task SetBypassCSPAsync(bool enabled) => Client.SendAsync("Page.setBypassCSP", new PageSetBypassCSPRequest683        {684            Enabled = enabled685        });686        /// <summary>687        /// Emulates a media such as screen or print.688        /// </summary>689        /// <returns>Task.</returns>690        /// <param name="media">Media to set.</param>691        [Obsolete("User EmulateMediaTypeAsync instead")]692        public Task EmulateMediaAsync(MediaType media) => EmulateMediaTypeAsync(media);693        /// <summary>694        /// Emulates a media such as screen or print.695        /// </summary>696        /// <param name="type">Media to set.</param>697        /// <example>698        /// <code>699        /// <![CDATA[700        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");701        /// // â true702        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");703        /// // â true704        /// await page.EmulateMediaTypeAsync(MediaType.Print);705        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");706        /// // â false707        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");708        /// // â true709        /// await page.EmulateMediaTypeAsync(MediaType.None);710        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");711        /// // â true712        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");713        /// // â true714        /// ]]>715        /// </code>716        /// </example>717        /// <returns>Emulate media type task.</returns>718        public Task EmulateMediaTypeAsync(MediaType type)719            => Client.SendAsync("Emulation.setEmulatedMedia", new EmulationSetEmulatedMediaTypeRequest { Media = type });720        /// <summary>721        /// Given an array of media feature objects, emulates CSS media features on the page.722        /// </summary>723        /// <param name="features">Features to apply</param>724        /// <example>725        /// <code>726        /// <![CDATA[727        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]{ new MediaFeature { MediaFeature =  MediaFeature.PrefersColorScheme, Value = "dark" }});728        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: dark)').matches)");729        /// // â true730        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: light)').matches)");731        /// // â false732        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");733        /// // â false734        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]{ new MediaFeature { MediaFeature = MediaFeature.PrefersReducedMotion, Value = "reduce" }});735        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-reduced-motion: reduce)').matches)");736        /// // â true737        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");738        /// // â false739        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]740        /// { 741        ///   new MediaFeature { MediaFeature = MediaFeature.PrefersColorScheme, Value = "dark" },742        ///   new MediaFeature { MediaFeature = MediaFeature.PrefersReducedMotion, Value = "reduce" },743        /// });744        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: dark)').matches)");745        /// // â true746        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: light)').matches)");747        /// // â false748        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");749        /// // â false750        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-reduced-motion: reduce)').matches)");751        /// // â true752        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");753        /// // â false754        /// ]]>755        /// </code>756        /// </example>757        /// <returns>Emulate features task</returns>758        public Task EmulateMediaFeaturesAsync(IEnumerable<MediaFeatureValue> features)759            => Client.SendAsync("Emulation.setEmulatedMedia", new EmulationSetEmulatedMediaFeatureRequest { Features = features });760        /// <summary>761        /// Sets the viewport.762        /// In the case of multiple pages in a single browser, each page can have its own viewport size.763        /// <see cref="SetViewportAsync(ViewPortOptions)"/> will resize the page. A lot of websites don't expect phones to change size, so you should set the viewport before navigating to the page.764        /// </summary>765        /// <example>766        ///<![CDATA[767        /// using(var page = await browser.NewPageAsync())768        /// {769        ///     await page.SetViewPortAsync(new ViewPortOptions770        ///     {771        ///         Width = 640, 772        ///         Height = 480, 773        ///         DeviceScaleFactor = 1774        ///     });775        ///     await page.goto('https://www.example.com');776        /// }777        /// ]]>778        /// </example>779        /// <returns>The viewport task.</returns>780        /// <param name="viewport">Viewport options.</param>781        public async Task SetViewportAsync(ViewPortOptions viewport)782        {783            var needsReload = await _emulationManager.EmulateViewport(viewport).ConfigureAwait(false);784            Viewport = viewport;785            if (needsReload)786            {787                await ReloadAsync().ConfigureAwait(false);788            }789        }790        /// <summary>791        /// Closes the page.792        /// </summary>793        /// <param name="options">Close options.</param>794        /// <returns>Task.</returns>795        public Task CloseAsync(PageCloseOptions options = null)796        {797            if (!(Client?.Connection?.IsClosed ?? true))798            {799                var runBeforeUnload = options?.RunBeforeUnload ?? false;800                if (runBeforeUnload)801                {802                    return Client.SendAsync("Page.close");803                }804                return Client.Connection.SendAsync("Target.closeTarget", new TargetCloseTargetRequest805                {806                    TargetId = Target.TargetId807                }).ContinueWith(task => Target.CloseTask);808            }809            return _closeCompletedTcs.Task;810        }811        /// <summary>812        /// Reloads the page813        /// </summary>814        /// <param name="options">Navigation options</param>815        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>816        /// <seealso cref="ReloadAsync(int?, WaitUntilNavigation[])"/>817        public async Task<Response> ReloadAsync(NavigationOptions options)818        {819            var navigationTask = WaitForNavigationAsync(options);820            await Task.WhenAll(821              navigationTask,822              Client.SendAsync("Page.reload")823            ).ConfigureAwait(false);824            return navigationTask.Result;825        }826        /// <summary>827        /// Reloads the page828        /// </summary>829        /// <param name="timeout">Maximum navigation time in milliseconds, defaults to 30 seconds, pass <c>0</c> to disable timeout. </param>830        /// <param name="waitUntil">When to consider navigation succeeded, defaults to <see cref="WaitUntilNavigation.Load"/>. Given an array of <see cref="WaitUntilNavigation"/>, navigation is considered to be successful after all events have been fired</param>831        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>832        /// <seealso cref="ReloadAsync(NavigationOptions)"/>833        public Task<Response> ReloadAsync(int? timeout = null, WaitUntilNavigation[] waitUntil = null)834            => ReloadAsync(new NavigationOptions { Timeout = timeout, WaitUntil = waitUntil });835        /// <summary>836        /// Waits for a function to be evaluated to a truthy value837        /// </summary>838        /// <param name="script">Function to be evaluated in browser context</param>839        /// <param name="options">Optional waiting parameters</param>840        /// <param name="args">Arguments to pass to <c>script</c></param>841        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>842        /// <seealso cref="Frame.WaitForFunctionAsync(string, WaitForFunctionOptions, object[])"/>843        public Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options = null, params object[] args)844            => MainFrame.WaitForFunctionAsync(script, options ?? new WaitForFunctionOptions(), args);845        /// <summary>846        /// Waits for an expression to be evaluated to a truthy value847        /// </summary>848        /// <param name="script">Expression to be evaluated in browser context</param>849        /// <param name="options">Optional waiting parameters</param>850        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>851        /// <seealso cref="Frame.WaitForExpressionAsync(string, WaitForFunctionOptions)"/>852        public Task<JSHandle> WaitForExpressionAsync(string script, WaitForFunctionOptions options = null)853            => MainFrame.WaitForExpressionAsync(script, options ?? new WaitForFunctionOptions());854        /// <summary>855        /// Waits for a selector to be added to the DOM856        /// </summary>857        /// <param name="selector">A selector of an element to wait for</param>858        /// <param name="options">Optional waiting parameters</param>859        /// <returns>A task that resolves when element specified by selector string is added to DOM.860        /// Resolves to `null` if waiting for `hidden: true` and selector is not found in DOM.</returns>861        /// <seealso cref="WaitForXPathAsync(string, WaitForSelectorOptions)"/>862        /// <seealso cref="Frame.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>863        public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)864            => MainFrame.WaitForSelectorAsync(selector, options ?? new WaitForSelectorOptions());865        /// <summary>866        /// Waits for a xpath selector to be added to the DOM867        /// </summary>868        /// <param name="xpath">A xpath selector of an element to wait for</param>869        /// <param name="options">Optional waiting parameters</param>870        /// <returns>A task which resolves when element specified by xpath string is added to DOM. 871        /// Resolves to `null` if waiting for `hidden: true` and xpath is not found in DOM.</returns>872        /// <example>873        /// <code>874        /// <![CDATA[875        /// var browser = await Puppeteer.LaunchAsync(new LaunchOptions());876        /// var page = await browser.NewPageAsync();877        /// string currentURL = null;878        /// page879        ///     .WaitForXPathAsync("//img")880        ///     .ContinueWith(_ => Console.WriteLine("First URL with image: " + currentURL));881        /// foreach (var current in new[] { "https://example.com", "https://google.com", "https://bbc.com" })882        /// {883        ///     currentURL = current;884        ///     await page.GoToAsync(currentURL);885        /// }886        /// await browser.CloseAsync();887        /// ]]>888        /// </code>889        /// </example>890        /// <seealso cref="WaitForSelectorAsync(string, WaitForSelectorOptions)"/>891        /// <seealso cref="Frame.WaitForXPathAsync(string, WaitForSelectorOptions)"/>892        public Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)893            => MainFrame.WaitForXPathAsync(xpath, options ?? new WaitForSelectorOptions());894        /// <summary>895        /// This resolves when the page navigates to a new URL or reloads.896        /// It is useful for when you run code which will indirectly cause the page to navigate.897        /// </summary>898        /// <param name="options">navigation options</param>899        /// <returns>Task which resolves to the main resource response. 900        /// In case of multiple redirects, the navigation will resolve with the response of the last redirect.901        /// In case of navigation to a different anchor or navigation due to History API usage, the navigation will resolve with `null`.902        /// </returns>903        /// <remarks>904        /// Usage of the <c>History API</c> <see href="https://developer.mozilla.org/en-US/docs/Web/API/History_API"/> to change the URL is considered a navigation905        /// </remarks>906        /// <example>907        /// <code>908        /// <![CDATA[909        /// var navigationTask = page.WaitForNavigationAsync();910        /// await page.ClickAsync("a.my-link");911        /// await navigationTask;912        /// ]]>913        /// </code>914        /// </example>915        public Task<Response> WaitForNavigationAsync(NavigationOptions options = null) => FrameManager.WaitForFrameNavigationAsync(FrameManager.MainFrame, options);916        /// <summary>917        /// Waits for a request.918        /// </summary>919        /// <example>920        /// <code>921        /// <![CDATA[922        /// var firstRequest = await page.WaitForRequestAsync("http://example.com/resource");923        /// return firstRequest.Url;924        /// ]]>925        /// </code>926        /// </example>927        /// <returns>A task which resolves when a matching request was made.</returns>928        /// <param name="url">URL to wait for.</param>929        /// <param name="options">Options.</param>930        public Task<Request> WaitForRequestAsync(string url, WaitForOptions options = null)931            => WaitForRequestAsync(request => request.Url == url, options);932        /// <summary>933        /// Waits for a request.934        /// </summary>935        /// <example>936        /// <code>937        /// <![CDATA[938        /// var request = await page.WaitForRequestAsync(request => request.Url === "http://example.com" && request.Method === HttpMethod.Get;939        /// return request.Url;940        /// ]]>941        /// </code>942        /// </example>943        /// <returns>A task which resolves when a matching request was made.</returns>944        /// <param name="predicate">Function which looks for a matching request.</param>945        /// <param name="options">Options.</param>946        public async Task<Request> WaitForRequestAsync(Func<Request, bool> predicate, WaitForOptions options = null)947        {948            var timeout = options?.Timeout ?? DefaultTimeout;949            var requestTcs = new TaskCompletionSource<Request>(TaskCreationOptions.RunContinuationsAsynchronously);950            void requestEventListener(object sender, RequestEventArgs e)951            {952                if (predicate(e.Request))953                {954                    requestTcs.TrySetResult(e.Request);955                    FrameManager.NetworkManager.Request -= requestEventListener;956                }957            }958            FrameManager.NetworkManager.Request += requestEventListener;959            await Task.WhenAny(requestTcs.Task, SessionClosedTask).WithTimeout(timeout, t =>960            {961                FrameManager.NetworkManager.Request -= requestEventListener;962                return new TimeoutException($"Timeout of {t.TotalMilliseconds} ms exceeded");963            }).ConfigureAwait(false);964            if (SessionClosedTask.IsFaulted)965            {966                await SessionClosedTask.ConfigureAwait(false);967            }968            return await requestTcs.Task.ConfigureAwait(false);969        }970        /// <summary>971        /// Waits for a response.972        /// </summary>973        /// <example>974        /// <code>975        /// <![CDATA[976        /// var firstResponse = await page.WaitForResponseAsync("http://example.com/resource");977        /// return firstResponse.Url;978        /// ]]>979        /// </code>980        /// </example>981        /// <returns>A task which resolves when a matching response is received.</returns>982        /// <param name="url">URL to wait for.</param>983        /// <param name="options">Options.</param>984        public Task<Response> WaitForResponseAsync(string url, WaitForOptions options = null)985            => WaitForResponseAsync(response => response.Url == url, options);986        /// <summary>987        /// Waits for a response.988        /// </summary>989        /// <example>990        /// <code>991        /// <![CDATA[992        /// var response = await page.WaitForResponseAsync(response => response.Url === "http://example.com" && response.Status === HttpStatus.Ok;993        /// return response.Url;994        /// ]]>995        /// </code>996        /// </example>997        /// <returns>A task which resolves when a matching response is received.</returns>998        /// <param name="predicate">Function which looks for a matching response.</param>999        /// <param name="options">Options.</param>1000        public async Task<Response> WaitForResponseAsync(Func<Response, bool> predicate, WaitForOptions options = null)1001        {1002            var timeout = options?.Timeout ?? DefaultTimeout;1003            var responseTcs = new TaskCompletionSource<Response>(TaskCreationOptions.RunContinuationsAsynchronously);1004            void responseEventListener(object sender, ResponseCreatedEventArgs e)1005            {1006                if (predicate(e.Response))1007                {1008                    responseTcs.TrySetResult(e.Response);1009                    FrameManager.NetworkManager.Response -= responseEventListener;1010                }1011            }1012            FrameManager.NetworkManager.Response += responseEventListener;1013            await Task.WhenAny(responseTcs.Task, SessionClosedTask).WithTimeout(timeout).ConfigureAwait(false);1014            if (SessionClosedTask.IsFaulted)1015            {1016                await SessionClosedTask.ConfigureAwait(false);1017            }1018            return await responseTcs.Task.ConfigureAwait(false);1019        }1020        /// <summary>1021        /// Navigate to the previous page in history.1022        /// </summary>1023        /// <returns>Task that resolves to the main resource response. In case of multiple redirects, 1024        /// the navigation will resolve with the response of the last redirect. If can not go back, resolves to null.</returns>1025        /// <param name="options">Navigation parameters.</param>1026        public Task<Response> GoBackAsync(NavigationOptions options = null) => GoAsync(-1, options);1027        /// <summary>1028        /// Navigate to the next page in history.1029        /// </summary>1030        /// <returns>Task that resolves to the main resource response. In case of multiple redirects, 1031        /// the navigation will resolve with the response of the last redirect. If can not go forward, resolves to null.</returns>1032        /// <param name="options">Navigation parameters.</param>1033        public Task<Response> GoForwardAsync(NavigationOptions options = null) => GoAsync(1, options);1034        /// <summary>1035        /// Resets the background color and Viewport after taking Screenshots using BurstMode.1036        /// </summary>1037        /// <returns>The burst mode off.</returns>1038        public Task SetBurstModeOffAsync()1039        {1040            return Task.CompletedTask;1041        }1042        #endregion1043        internal void OnPopup(Page popupPage) => Popup?.Invoke(this, new PopupEventArgs { PopupPage = popupPage });1044        #region Private Method1045        internal static async Task<Page> CreateAsync(1046            CDPSession client,1047            Target target,1048            bool ignoreHTTPSErrors,1049            ViewPortOptions defaultViewPort,1050            TaskQueue screenshotTaskQueue)1051        {1052            var page = new Page(client, target, screenshotTaskQueue);1053            await page.InitializeAsync(ignoreHTTPSErrors).ConfigureAwait(false);1054            if (defaultViewPort != null)1055            {1056                await page.SetViewportAsync(defaultViewPort).ConfigureAwait(false);1057            }1058            return page;1059        }1060        private async Task InitializeAsync(bool ignoreHTTPSErrors)1061        {1062            FrameManager = await FrameManager.CreateFrameManagerAsync(Client, this, ignoreHTTPSErrors, _timeoutSettings).ConfigureAwait(false);1063            var networkManager = FrameManager.NetworkManager;1064            Client.MessageReceived += Client_MessageReceived;1065            FrameManager.FrameAttached += (sender, e) => FrameAttached?.Invoke(this, e);1066            FrameManager.FrameDetached += (sender, e) => FrameDetached?.Invoke(this, e);1067            FrameManager.FrameNavigated += (sender, e) => FrameNavigated?.Invoke(this, e);1068            networkManager.Request += (sender, e) => Request?.Invoke(this, e);1069            networkManager.RequestFailed += (sender, e) => RequestFailed?.Invoke(this, e);1070            networkManager.Response += (sender, e) => Response?.Invoke(this, e);1071            networkManager.RequestFinished += (sender, e) => RequestFinished?.Invoke(this, e);1072            await Task.WhenAll(1073               Client.SendAsync("Target.setAutoAttach", new TargetSetAutoAttachRequest1074               {1075                   AutoAttach = true,1076                   WaitForDebuggerOnStart = false,1077                   Flatten = true1078               }),1079               Client.SendAsync("Performance.enable", null),1080               Client.SendAsync("Log.enable", null)1081           ).ConfigureAwait(false);...

ElementHandle.cs

Source:ElementHandle.cs

...16    /// ElementHandles can be created by <see cref="PuppeteerSharp.Page.QuerySelectorAsync(string)"/> or <see cref="PuppeteerSharp.Page.QuerySelectorAllAsync(string)"/>.17    /// </summary>18    public class ElementHandle : JSHandle19    {20        private readonly FrameManager _frameManager;21        private readonly ILogger<ElementHandle> _logger;22        internal ElementHandle(23            ExecutionContext context,24            CDPSession client,25            RemoteObject remoteObject,26            Page page,27            FrameManager frameManager) : base(context, client, remoteObject)28        {29            Page = page;30            _frameManager = frameManager;31            _logger = client.LoggerFactory.CreateLogger<ElementHandle>();32        }33        internal Page Page { get; }34        /// <summary>35        /// This method scrolls element into view if needed, and then uses <seealso cref="PuppeteerSharp.Page.ScreenshotDataAsync(ScreenshotOptions)"/> to take a screenshot of the element.36        /// If the element is detached from DOM, the method throws an error.37        /// </summary>38        /// <returns>The task</returns>39        /// <param name="file">The file path to save the image to. The screenshot type will be inferred from file extension.40        /// If path is a relative path, then it is resolved relative to current working directory. If no path is provided,41        /// the image won't be saved to the disk.</param>...

FrameManager.cs

Source:FrameManager.cs

...8using System.Linq;9using System.Threading.Tasks;10namespace PuppeteerSharp11{12    internal class FrameManager13    {14        private Dictionary<int, ExecutionContext> _contextIdToContext;15        private bool _ensureNewDocumentNavigation;16        private readonly ConcurrentDictionary<string, Frame> _frames;17        private const string RefererHeaderName = "referer";18        private readonly AsyncDictionaryHelper<string, Frame> _asyncFrames;19        private readonly List<string> _isolatedWorlds = new List<string>();20        private const string UtilityWorldName = "__puppeteer_utility_world__";21        private FrameManager(CDPSession client, Page page, bool ignoreHTTPSErrors, TimeoutSettings timeoutSettings)22        {23            Client = client;24            Page = page;25            _frames = new ConcurrentDictionary<string, Frame>();26            _contextIdToContext = new Dictionary<int, ExecutionContext>();27            NetworkManager = new NetworkManager(client, ignoreHTTPSErrors, this);28            TimeoutSettings = timeoutSettings;29            _asyncFrames = new AsyncDictionaryHelper<string, Frame>(_frames, "Frame {0} not found");30            Client.MessageReceived += Client_MessageReceived;31        }32        #region Properties33        internal event EventHandler<FrameEventArgs> FrameAttached;34        internal event EventHandler<FrameEventArgs> FrameDetached;35        internal event EventHandler<FrameEventArgs> FrameNavigated;36        internal event EventHandler<FrameEventArgs> FrameNavigatedWithinDocument;37        internal event EventHandler<FrameEventArgs> LifecycleEvent;38        internal CDPSession Client { get; }39        internal NetworkManager NetworkManager { get; }40        internal Frame MainFrame { get; set; }41        internal Page Page { get; }42        internal TimeoutSettings TimeoutSettings { get; }43        #endregion44        #region Public Methods45        internal static async Task<FrameManager> CreateFrameManagerAsync(46            CDPSession client,47            Page page,48            bool ignoreHTTPSErrors,49            TimeoutSettings timeoutSettings)50        {51            var frameManager = new FrameManager(client, page, ignoreHTTPSErrors, timeoutSettings);52            var getFrameTreeTask = client.SendAsync<PageGetFrameTreeResponse>("Page.getFrameTree");53            await Task.WhenAll(54                client.SendAsync("Page.enable"),55                getFrameTreeTask).ConfigureAwait(false);56            await frameManager.HandleFrameTreeAsync(new FrameTree(getFrameTreeTask.Result.FrameTree)).ConfigureAwait(false);57            await Task.WhenAll(58                client.SendAsync("Page.setLifecycleEventsEnabled", new PageSetLifecycleEventsEnabledRequest { Enabled = true }),59                client.SendAsync("Runtime.enable"),60                frameManager.NetworkManager.InitializeAsync()).ConfigureAwait(false);61            await frameManager.EnsureIsolatedWorldAsync().ConfigureAwait(false);62            return frameManager;63        }64        internal ExecutionContext ExecutionContextById(int contextId)65        {...

NetworkManager.cs

Source:NetworkManager.cs

...23        private bool _protocolRequestInterceptionEnabled;24        private readonly bool _ignoreHTTPSErrors;25        private bool _userCacheDisabled;26        #endregion27        internal NetworkManager(CDPSession client, bool ignoreHTTPSErrors, FrameManager frameManager)28        {29            FrameManager = frameManager;30            _client = client;31            _ignoreHTTPSErrors = ignoreHTTPSErrors;32            _client.MessageReceived += Client_MessageReceived;33        }34        #region Public Properties35        internal Dictionary<string, string> ExtraHTTPHeaders => _extraHTTPHeaders?.Clone();36        internal event EventHandler<ResponseCreatedEventArgs> Response;37        internal event EventHandler<RequestEventArgs> Request;38        internal event EventHandler<RequestEventArgs> RequestFinished;39        internal event EventHandler<RequestEventArgs> RequestFailed;40        internal FrameManager FrameManager { get; set; }41        #endregion42        #region Public Methods43        internal async Task InitializeAsync()44        {45            await _client.SendAsync("Network.enable").ConfigureAwait(false);46            if (_ignoreHTTPSErrors)47            {48                await _client.SendAsync("Security.setIgnoreCertificateErrors", new SecuritySetIgnoreCertificateErrorsRequest49                {50                    Ignore = true51                }).ConfigureAwait(false);52            }53        }54        internal Task AuthenticateAsync(Credentials credentials)55        {56            _credentials = credentials;57            return UpdateProtocolRequestInterceptionAsync();58        }59        internal Task SetExtraHTTPHeadersAsync(Dictionary<string, string> extraHTTPHeaders)60        {61            _extraHTTPHeaders = new Dictionary<string, string>();62            foreach (var item in extraHTTPHeaders)63            {64                _extraHTTPHeaders[item.Key.ToLower()] = item.Value;65            }66            return _client.SendAsync("Network.setExtraHTTPHeaders", new NetworkSetExtraHTTPHeadersRequest67            {68                Headers = _extraHTTPHeaders69            });70        }71        internal async Task SetOfflineModeAsync(bool value)72        {73            if (_offine != value)74            {75                _offine = value;76                await _client.SendAsync("Network.emulateNetworkConditions", new NetworkEmulateNetworkConditionsRequest77                {78                    Offline = value,79                    Latency = 0,80                    DownloadThroughput = -1,81                    UploadThroughput = -182                }).ConfigureAwait(false);83            }84        }85        internal Task SetUserAgentAsync(string userAgent)86            => _client.SendAsync("Network.setUserAgentOverride", new NetworkSetUserAgentOverrideRequest87            {88                UserAgent = userAgent89            });90        internal Task SetCacheEnabledAsync(bool enabled)91        {92            _userCacheDisabled = !enabled;93            return UpdateProtocolCacheDisabledAsync();94        }95        internal Task SetRequestInterceptionAsync(bool value)96        {97            _userRequestInterceptionEnabled = value;98            return UpdateProtocolRequestInterceptionAsync();99        }100        #endregion101        #region Private Methods102        private Task UpdateProtocolCacheDisabledAsync()103            => _client.SendAsync("Network.setCacheDisabled", new NetworkSetCacheDisabledRequest104            {105                CacheDisabled = _userCacheDisabled || _protocolRequestInterceptionEnabled106            });107        private async void Client_MessageReceived(object sender, MessageEventArgs e)108        {109            try110            {111                switch (e.MessageID)112                {113                    case "Fetch.requestPaused":114                        await OnRequestPausedAsync(e.MessageData.ToObject<FetchRequestPausedResponse>(true)).ConfigureAwait(false);115                        break;116                    case "Fetch.authRequired":117                        await OnAuthRequiredAsync(e.MessageData.ToObject<FetchAuthRequiredResponse>(true)).ConfigureAwait(false);118                        break;119                    case "Network.requestWillBeSent":120                        await OnRequestWillBeSentAsync(e.MessageData.ToObject<RequestWillBeSentPayload>(true)).ConfigureAwait(false);121                        break;122                    case "Network.requestServedFromCache":123                        OnRequestServedFromCache(e.MessageData.ToObject<RequestServedFromCacheResponse>(true));124                        break;125                    case "Network.responseReceived":126                        OnResponseReceived(e.MessageData.ToObject<ResponseReceivedResponse>(true));127                        break;128                    case "Network.loadingFinished":129                        OnLoadingFinished(e.MessageData.ToObject<LoadingFinishedResponse>(true));130                        break;131                    case "Network.loadingFailed":132                        OnLoadingFailed(e.MessageData.ToObject<LoadingFailedResponse>(true));133                        break;134                }135            }136            catch (Exception ex)137            {138                var message = $"NetworkManager failed to process {e.MessageID}. {ex.Message}. {ex.StackTrace}";139                _client.Close(message);140            }141        }142        private void OnLoadingFailed(LoadingFailedResponse e)143        {144            // For certain requestIds we never receive requestWillBeSent event.145            // @see https://crbug.com/750469146            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))147            {148                request.Failure = e.ErrorText;149                request.Response?.BodyLoadedTaskWrapper.TrySetResult(true);150                _requestIdToRequest.TryRemove(request.RequestId, out _);151                if (request.InterceptionId != null)152                {153                    _attemptedAuthentications.Remove(request.InterceptionId);154                }155                RequestFailed?.Invoke(this, new RequestEventArgs156                {157                    Request = request158                });159            }160        }161        private void OnLoadingFinished(LoadingFinishedResponse e)162        {163            // For certain requestIds we never receive requestWillBeSent event.164            // @see https://crbug.com/750469165            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))166            {167                request.Response?.BodyLoadedTaskWrapper.TrySetResult(true);168                _requestIdToRequest.TryRemove(request.RequestId, out _);169                if (request.InterceptionId != null)170                {171                    _attemptedAuthentications.Remove(request.InterceptionId);172                }173                RequestFinished?.Invoke(this, new RequestEventArgs174                {175                    Request = request176                });177            }178        }179        private void OnResponseReceived(ResponseReceivedResponse e)180        {181            // FileUpload sends a response without a matching request.182            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))183            {184                var response = new Response(185                    _client,186                    request,187                    e.Response);188                request.Response = response;189                Response?.Invoke(this, new ResponseCreatedEventArgs190                {191                    Response = response192                });193            }194        }195        private async Task OnAuthRequiredAsync(FetchAuthRequiredResponse e)196        {197            var response = "Default";198            if (_attemptedAuthentications.Contains(e.RequestId))199            {200                response = "CancelAuth";201            }202            else if (_credentials != null)203            {204                response = "ProvideCredentials";205                _attemptedAuthentications.Add(e.RequestId);206            }207            var credentials = _credentials ?? new Credentials();208            try209            {210                await _client.SendAsync("Fetch.continueWithAuth", new ContinueWithAuthRequest211                {212                    RequestId = e.RequestId,213                    AuthChallengeResponse = new ContinueWithAuthRequestChallengeResponse214                    {215                        Response = response,216                        Username = credentials.Username,217                        Password = credentials.Password218                    }219                }).ConfigureAwait(false);220            }221            catch { }222        }223        private async Task OnRequestPausedAsync(FetchRequestPausedResponse e)224        {225            if (!_userRequestInterceptionEnabled && _protocolRequestInterceptionEnabled)226            {227                try228                {229                    await _client.SendAsync("Fetch.continueRequest", new FetchContinueRequestRequest230                    {231                        RequestId = e.RequestId232                    }).ConfigureAwait(false);233                }234                catch { }235            }236            var requestId = e.NetworkId;237            var interceptionId = e.RequestId;238            if (!string.IsNullOrEmpty(requestId))239            {240                if (_requestIdToRequestWillBeSentEvent.TryRemove(requestId, out var requestWillBeSentEvent))241                {242                    await OnRequestAsync(requestWillBeSentEvent, interceptionId).ConfigureAwait(false);243                }244                else245                {246                    _requestIdToInterceptionId[requestId] = interceptionId;247                }248            }249        }250        private async Task OnRequestAsync(RequestWillBeSentPayload e, string interceptionId)251        {252            Request request;253            var redirectChain = new List<Request>();254            if (e.RedirectResponse != null)255            {256                _requestIdToRequest.TryGetValue(e.RequestId, out request);257                // If we connect late to the target, we could have missed the requestWillBeSent event.258                if (request != null)259                {260                    HandleRequestRedirect(request, e.RedirectResponse);261                    redirectChain = request.RedirectChainList;262                }263            }264            if (!_requestIdToRequest.TryGetValue(e.RequestId, out var currentRequest) ||265              currentRequest.Frame == null)266            {267                var frame = !string.IsNullOrEmpty(e.FrameId) ? await FrameManager.TryGetFrameAsync(e.FrameId).ConfigureAwait(false) : null;268                request = new Request(269                    _client,270                    frame,271                    interceptionId,272                    _userRequestInterceptionEnabled,273                    e,274                    redirectChain);275                _requestIdToRequest[e.RequestId] = request;276                Request?.Invoke(this, new RequestEventArgs277                {278                    Request = request279                });280            }281        }...

DOMWorld.cs

Source:DOMWorld.cs

...6namespace PuppeteerSharp7{8    internal class DOMWorld9    {10        private readonly FrameManager _frameManager;11        private readonly TimeoutSettings _timeoutSettings;12        private bool _detached;13        private TaskCompletionSource<ExecutionContext> _contextResolveTaskWrapper;14        private TaskCompletionSource<ElementHandle> _documentCompletionSource;15        internal List<WaitTask> WaitTasks { get; set; }16        internal Frame Frame { get; }17        public DOMWorld(FrameManager frameManager, Frame frame, TimeoutSettings timeoutSettings)18        {19            _frameManager = frameManager;20            Frame = frame;21            _timeoutSettings = timeoutSettings;22            SetContext(null);23            WaitTasks = new List<WaitTask>();24            _detached = false;25        }26        internal void SetContext(ExecutionContext context)27        {28            if (context != null)29            {30                _contextResolveTaskWrapper.TrySetResult(context);31                foreach (var waitTask in WaitTasks)...

ExecutionContext.cs

Source:ExecutionContext.cs

...160            }161        }162        internal JSHandle CreateJSHandle(RemoteObject remoteObject)163            => remoteObject.Subtype == RemoteObjectSubtype.Node && Frame != null164                ? new ElementHandle(this, _client, remoteObject, Frame.FrameManager.Page, Frame.FrameManager)165                : new JSHandle(this, _client, remoteObject);166        private object FormatArgument(object arg)167        {168            switch (arg)169            {170                case BigInteger big:171                    return new { unserializableValue = $"{big}n" };172                case int integer when integer == -0:173                    return new { unserializableValue = "-0" };174                case double d:175                    if (double.IsPositiveInfinity(d))176                    {177                        return new { unserializableValue = "Infinity" };178                    }...

LifecycleWatcher.cs

Source:LifecycleWatcher.cs

...16                [WaitUntilNavigation.Networkidle0] = "networkIdle",17                [WaitUntilNavigation.Networkidle2] = "networkAlmostIdle"18            };19        private static readonly WaitUntilNavigation[] _defaultWaitUntil = { WaitUntilNavigation.Load };20        private readonly FrameManager _frameManager;21        private readonly Frame _frame;22        private readonly IEnumerable<string> _expectedLifecycle;23        private readonly int _timeout;24        private readonly string _initialLoaderId;25        private Request _navigationRequest;26        private bool _hasSameDocumentNavigation;27        private TaskCompletionSource<bool> _newDocumentNavigationTaskWrapper;28        private TaskCompletionSource<bool> _sameDocumentNavigationTaskWrapper;29        private TaskCompletionSource<bool> _lifecycleTaskWrapper;30        private TaskCompletionSource<bool> _terminationTaskWrapper;31        public LifecycleWatcher(32            FrameManager frameManager,33            Frame frame,34            WaitUntilNavigation[] waitUntil,35            int timeout)36        {37            _expectedLifecycle = (waitUntil ?? _defaultWaitUntil).Select(w =>38            {39                var protocolEvent = _puppeteerToProtocolLifecycle.GetValueOrDefault(w);40                Contract.Assert(protocolEvent != null, $"Unknown value for options.waitUntil: {w}");41                return protocolEvent;42            });43            _frameManager = frameManager;44            _frame = frame;45            _initialLoaderId = frame.LoaderId;46            _timeout = timeout;47            _hasSameDocumentNavigation = false;48            _sameDocumentNavigationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);49            _newDocumentNavigationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);50            _lifecycleTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);51            _terminationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);52            frameManager.LifecycleEvent += FrameManager_LifecycleEvent;53            frameManager.FrameNavigatedWithinDocument += NavigatedWithinDocument;54            frameManager.FrameDetached += OnFrameDetached;55            frameManager.NetworkManager.Request += OnRequest;56            frameManager.Client.Disconnected += OnClientDisconnected;57            CheckLifecycleComplete();58        }59        #region Properties60        public Task<Task> NavigationTask { get; internal set; }61        public Task<bool> SameDocumentNavigationTask => _sameDocumentNavigationTaskWrapper.Task;62        public Task<bool> NewDocumentNavigationTask => _newDocumentNavigationTaskWrapper.Task;63        public Response NavigationResponse => _navigationRequest?.Response;64        public Task TimeoutOrTerminationTask65            => _terminationTaskWrapper.Task.WithTimeout(_timeout);66        public Task LifecycleTask => _lifecycleTaskWrapper.Task;67        #endregion68        #region Private methods69        private void OnClientDisconnected(object sender, EventArgs e)70            => Terminate(new TargetClosedException("Navigation failed because browser has disconnected!", _frameManager.Client.CloseReason));71        void FrameManager_LifecycleEvent(object sender, FrameEventArgs e) => CheckLifecycleComplete();7273        private void OnFrameDetached(object sender, FrameEventArgs e)74        {75            var frame = e.Frame;76            if (_frame == frame)77            {78                Terminate(new PuppeteerException("Navigating frame was detached"));79                return;80            }81            CheckLifecycleComplete();82        }83        private void CheckLifecycleComplete()84        {85            // We expect navigation to commit.86            if (!CheckLifecycle(_frame, _expectedLifecycle))87            {88                return;89            }90            _lifecycleTaskWrapper.TrySetResult(true);91            if (_frame.LoaderId == _initialLoaderId && !_hasSameDocumentNavigation)92            {93                return;94            }95            if (_hasSameDocumentNavigation)96            {97                _sameDocumentNavigationTaskWrapper.TrySetResult(true);98            }99            if (_frame.LoaderId != _initialLoaderId)100            {101                _newDocumentNavigationTaskWrapper.TrySetResult(true);102            }103        }104        private void Terminate(PuppeteerException ex) => _terminationTaskWrapper.TrySetException(ex);105        private void OnRequest(object sender, RequestEventArgs e)106        {107            if (e.Request.Frame != _frame || !e.Request.IsNavigationRequest)108            {109                return;110            }111            _navigationRequest = e.Request;112        }113        private void NavigatedWithinDocument(object sender, FrameEventArgs e)114        {115            if (e.Frame != _frame)116            {117                return;118            }119            _hasSameDocumentNavigation = true;120            CheckLifecycleComplete();121        }122        private bool CheckLifecycle(Frame frame, IEnumerable<string> expectedLifecycle)123        {124            foreach (var item in expectedLifecycle)125            {126                if (!frame.LifecycleEvents.Contains(item))127                {128                    return false;129                }130            }131            foreach (var child in frame.ChildFrames)132            {133                if (!CheckLifecycle(child, expectedLifecycle))134                {135                    return false;136                }137            }138            return true;139        }140        public void Dispose() => Dispose(true);141        ~LifecycleWatcher() => Dispose(false);142        public void Dispose(bool disposing)143        {144            _frameManager.LifecycleEvent -= FrameManager_LifecycleEvent;145            _frameManager.FrameNavigatedWithinDocument -= NavigatedWithinDocument;146            _frameManager.FrameDetached -= OnFrameDetached;147            _frameManager.NetworkManager.Request -= OnRequest;148            _frameManager.Client.Disconnected -= OnClientDisconnected;149        }150        #endregion151    }152}...

NavigatorWatcher.cs

Source:NavigatorWatcher.cs

...16            [WaitUntilNavigation.DOMContentLoaded] = "DOMContentLoaded",17            [WaitUntilNavigation.Networkidle0] = "networkIdle",18            [WaitUntilNavigation.Networkidle2] = "networkAlmostIdle"19        };20        private FrameManager _frameManager;21        private Frame _frame;22        private NavigationOptions _options;23        private IEnumerable<string> _expectedLifecycle;24        private int _timeout;25        private string _initialLoaderId;26        public NavigatorWatcher(FrameManager frameManager, Frame mainFrame, int timeout, NavigationOptions options)27        {28            var waitUntil = new[] { WaitUntilNavigation.Load };2930            if (options?.WaitUntil != null)31            {32                waitUntil = options.WaitUntil;33            }3435            _expectedLifecycle = waitUntil.Select(w =>36            {37                var protocolEvent = _puppeteerToProtocolLifecycle.GetValueOrDefault(w);38                Contract.Assert(protocolEvent != null, $"Unknown value for options.waitUntil: {w}");39                return protocolEvent;40            });4142            _frameManager = frameManager;43            _frame = mainFrame;44            _options = options;45            _initialLoaderId = mainFrame.LoaderId;46            _timeout = timeout;4748            frameManager.LifecycleEvent += FrameManager_LifecycleEvent;49            frameManager.FrameDetached += FrameManager_LifecycleEvent;50            LifeCycleCompleteTaskWrapper = new TaskCompletionSource<bool>();5152            NavigationTask = Task.WhenAny(new[]53            {54                CreateTimeoutTask(),55                LifeCycleCompleteTask,56            }).ContinueWith((task) =>57            {58                CleanUp();59                return task.GetAwaiter().GetResult();60            });61        }62        #region Properties63        public Task<Task> NavigationTask { get; internal set; }64        public Task<bool> LifeCycleCompleteTask => LifeCycleCompleteTaskWrapper.Task;65        public TaskCompletionSource<bool> LifeCycleCompleteTaskWrapper { get; }66        #endregion67        #region Public methods68        public void Cancel()69        {70            CleanUp();71        }72        #endregion73        #region Private methods74        void FrameManager_LifecycleEvent(object sender, FrameEventArgs e)75        {76            // We expect navigation to commit.77            if (_frame.LoaderId == _initialLoaderId)78            {79                return;80            }81            if (!CheckLifecycle(_frame, _expectedLifecycle))82            {83                return;84            }8586            if (!LifeCycleCompleteTaskWrapper.Task.IsCompleted)87            {88                LifeCycleCompleteTaskWrapper.SetResult(true);89            }90        }9192        private bool CheckLifecycle(Frame frame, IEnumerable<string> expectedLifecycle)93        {94            foreach (var item in expectedLifecycle)95            {96                if (!frame.LifecycleEvents.Contains(item))97                {98                    return false;99                }100            }101            foreach (var child in frame.ChildFrames)102            {103                if (!CheckLifecycle(child, expectedLifecycle))104                {105                    return false;106                }107            }108            return true;109        }110        private void CleanUp()111        {112            _frameManager.LifecycleEvent -= FrameManager_LifecycleEvent;113            _frameManager.FrameDetached -= FrameManager_LifecycleEvent;114        }115        private async Task CreateTimeoutTask()116        {117            var wrapper = new TaskCompletionSource<bool>();118119            if (_timeout == 0)120            {121                await Task.Delay(-1);122            }123            else124            {125                await Task.Delay(_timeout);126                throw new NavigationException($"Navigation Timeout Exceeded: {_timeout}ms exceeded");127            }
...

FrameManager

Using AI Code Generation

1using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions2{3    Args = new[] { "--no-sandbox" }4}))5{6    var page = await browser.NewPageAsync();7    await page.ScreenshotAsync("screenshot.png");8}9using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions10{11    Args = new[] { "--no-sandbox" }12}))13{14    var page = await browser.NewPageAsync();15    await page.ScreenshotAsync("screenshot.png");16}17using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions18{19    Args = new[] { "--no-sandbox" }20}))21{22    var page = await browser.NewPageAsync();23    await page.ScreenshotAsync("screenshot.png");24}25using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions26{27    Args = new[] { "--no-sandbox" }28}))29{30    var page = await browser.NewPageAsync();31    await page.ScreenshotAsync("screenshot.png");32}33using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions34{35    Args = new[] { "--no-sandbox" }36}))37{38    var page = await browser.NewPageAsync();39    await page.ScreenshotAsync("screenshot.png");40}41using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions42{43    Args = new[] { "--no-sandbox" }44}))45{

FrameManager

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 LaunchOptions9            {10                Args = new string[] { "--start-maximized" }11            });12            var page = await browser.NewPageAsync();13            await page.ScreenshotAsync("google.png");14            await browser.CloseAsync();15        }16    }17}

FrameManager

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            Console.WriteLine("Hello World!");9            {10            };11            using (var browser = await Puppeteer.LaunchAsync(options))12            {13                using (var page = await browser.NewPageAsync())14                {15                    await page.ScreenshotAsync("google.png");16                    var frames = await page.FramesAsync();17                    foreach (var frame in frames)18                    {19                        Console.WriteLine(frame.Name);20                    }21                    var frame2 = await page.FrameAsync("iframe");22                    var button = await frame2.QuerySelectorAsync("button");23                    await button.ClickAsync();

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.