How to use TargetChangedArgs class of PuppeteerSharp package

Best Puppeteer-sharp code snippet using PuppeteerSharp.TargetChangedArgs

PuppeteerBrowserBuilder.cs

Source:PuppeteerBrowserBuilder.cs

...230                        {231                            _logger.Warn($"Diagonal Clicks Try#{retryN}");232                        });233            }234            private void _browser_TargetDestroyed(object sender, TargetChangedArgs e)235            {236                _logger.Warn($"Browser: Target has been destroyed");237            }238            private void _browser_TargetCreated(object sender, TargetChangedArgs e)239            {240                _logger.Warn($"Browser: Target has been created");241            }242            private void _browser_TargetChanged(object sender, TargetChangedArgs e)243            {244                _logger.Warn($"Browser: Target has been changed");245            }246            private void _browser_Disconnected(object sender, EventArgs e)247            {248                _logger.Warn("Browser has been disconnected");249            }250            private void _browser_Closed(object sender, EventArgs e)251            {252                _logger.Warn("Browser has been closed");253            }254            /// <summary>255            /// Setup the chromium for browser automation256            /// </summary>...

Browser.cs

Source:Browser.cs

...69        public event EventHandler Disconnected;70        /// <summary>71        /// Raised when the url of a target changes72        /// </summary>73        public event EventHandler<TargetChangedArgs> TargetChanged;74        /// <summary>75        /// Raised when a target is created, for example when a new page is opened by <c>window.open</c> <see href="https://developer.mozilla.org/en-US/docs/Web/API/Window/open"/> or <see cref="NewPageAsync"/>.76        /// </summary>77        public event EventHandler<TargetChangedArgs> TargetCreated;78        /// <summary>79        /// Raised when a target is destroyed, for example when a page is closed80        /// </summary>81        public event EventHandler<TargetChangedArgs> TargetDestroyed;82        /// <summary>83        /// Gets the Browser websocket url84        /// </summary>85        /// <remarks>86        /// Browser websocket endpoint which can be used as an argument to <see cref="Puppeteer.ConnectAsync(ConnectOptions, ILoggerFactory)"/>.87        /// The format is <c>ws://${host}:${port}/devtools/browser/[id]</c>88        /// You can find the <c>webSocketDebuggerUrl</c> from <c>http://${host}:${port}/json/version</c>.89        /// Learn more about the devtools protocol <see href="https://chromedevtools.github.io/devtools-protocol"/> 90        /// and the browser endpoint <see href="https://chromedevtools.github.io/devtools-protocol/#how-do-i-access-the-browser-target"/>91        /// </remarks>92        public string WebSocketEndpoint => Connection.Url;93        /// <summary>94        /// Gets the spawned browser process. Returns <c>null</c> if the browser instance was created with <see cref="Puppeteer.ConnectAsync(ConnectOptions, ILoggerFactory)"/> method.95        /// </summary>96        public Process Process { get; }97        /// <summary>98        /// Gets or Sets whether to ignore HTTPS errors during navigation99        /// </summary>100        public bool IgnoreHTTPSErrors { get; set; }101        /// <summary>102        /// Gets or Sets whether to use appMode or not103        /// </summary>104        public bool AppMode { get; set; }105        /// <summary>106        /// Gets a value indicating if the browser is closed107        /// </summary>108        public bool IsClosed { get; internal set; }109        internal TaskQueue ScreenshotTaskQueue { get; set; }110        internal Connection Connection { get; }111        #endregion112        #region Public Methods113        /// <summary>114        /// Creates a new page115        /// </summary>116        /// <returns>Task which resolves to a new <see cref="Page"/> object</returns>117        public async Task<Page> NewPageAsync()118        {119            string targetId = (await Connection.SendAsync("Target.createTarget", new Dictionary<string, object>(){120                {"url", "about:blank"}121              })).targetId.ToString();122            var target = _targets[targetId];123            await target.InitializedTask;124            return await target.PageAsync();125        }126        /// <summary>127        /// Returns An Array of all active targets128        /// </summary>129        /// <returns>An Array of all active targets</returns>130        public Target[] Targets() => _targets.Values.Where(target => target.IsInitialized).ToArray();131        /// <summary>132        /// Returns a Task which resolves to an array of all open pages.133        /// </summary>134        /// <returns>Task which resolves to an array of all open pages.</returns>135        public async Task<Page[]> PagesAsync()136            => (await Task.WhenAll(Targets().Select(target => target.PageAsync()))).Where(x => x != null).ToArray();137        /// <summary>138        /// Gets the browser's version139        /// </summary>140        /// <returns>For headless Chromium, this is similar to <c>HeadlessChrome/61.0.3153.0</c>. For non-headless, this is similar to <c>Chrome/61.0.3153.0</c></returns>141        /// <remarks>142        /// the format of <see cref="GetVersionAsync"/> might change with future releases of Chromium143        /// </remarks>144        public async Task<string> GetVersionAsync()145        {146            dynamic version = await Connection.SendAsync("Browser.getVersion");147            return version.product.ToString();148        }149        /// <summary>150        /// Gets the browser's original user agent151        /// </summary>152        /// <returns>Task which resolves to the browser's original user agent</returns>153        /// <remarks>154        /// Pages can override browser user agent with <see cref="Page.SetUserAgentAsync(string)"/>155        /// </remarks>156        public async Task<string> GetUserAgentAsync()157        {158            dynamic version = await Connection.SendAsync("Browser.getVersion");159            return version.userAgent.ToString();160        }161        /// <summary>162        /// Disconnects Puppeteer from the browser, but leaves the Chromium process running. After calling <see cref="Disconnect"/>, the browser object is considered disposed and cannot be used anymore163        /// </summary>164        public void Disconnect() => Connection.Dispose();165        /// <summary>166        /// Closes Chromium and all of its pages (if any were opened). The browser object itself is considered disposed and cannot be used anymore167        /// </summary>168        /// <returns>Task</returns>169        public async Task CloseAsync()170        {171            if (IsClosed)172            {173                return;174            }175            IsClosed = true;176            Connection.StopReading();177            var closeTask = _closeCallBack();178            if (closeTask != null)179            {180                await closeTask;181            }182            Disconnect();183            Closed?.Invoke(this, new EventArgs());184        }185        #endregion186        #region Private Methods187        internal void ChangeTarget(Target target)188        {189            TargetChanged?.Invoke(this, new TargetChangedArgs190            {191                Target = target192            });193        }194        private async void Connect_MessageReceived(object sender, MessageEventArgs args)195        {196            switch (args.MessageID)197            {198                case "Target.targetCreated":199                    await CreateTarget(args);200                    return;201                case "Target.targetDestroyed":202                    DestroyTarget(args);203                    return;204                case "Target.targetInfoChanged":205                    ChangeTargetInfo(args);206                    return;207            }208        }209        private void ChangeTargetInfo(MessageEventArgs args)210        {211            if (!_targets.ContainsKey(args.MessageData.targetInfo.targetId.Value))212            {213                throw new InvalidTargetException("Target should exists before ChangeTargetInfo");214            }215            string targetId = args.MessageData.targetInfo.targetId.Value;216            var target = _targets[targetId];217            target.TargetInfoChanged(new TargetInfo(args.MessageData.targetInfo));218        }219        private void DestroyTarget(MessageEventArgs args)220        {221            if (!_targets.ContainsKey(args.MessageData.targetId.ToString()))222            {223                throw new InvalidTargetException("Target should exists before DestroyTarget");224            }225            var target = _targets[args.MessageData.targetId.ToString()];226            if (!target.InitilizedTaskWrapper.Task.IsCompleted)227            {228                target.InitilizedTaskWrapper.SetResult(false);229            }230            _targets.Remove(args.MessageData.targetId.ToString());231            TargetDestroyed?.Invoke(this, new TargetChangedArgs()232            {233                Target = target234            });235        }236        private async Task CreateTarget(MessageEventArgs args)237        {238            var targetInfo = new TargetInfo(args.MessageData.targetInfo);239            var target = new Target(this, targetInfo);240            _targets[targetInfo.TargetId] = target;241            if (await target.InitializedTask)242            {243                TargetCreated?.Invoke(this, new TargetChangedArgs()244                {245                    Target = target246                });247            }248        }249        internal static async Task<Browser> CreateAsync(250            Connection connection, IBrowserOptions options, Process process, Func<Task> closeCallBack)251        {252            var browser = new Browser(connection, options, process, closeCallBack);253            await connection.SendAsync("Target.setDiscoverTargets", new254            {255                discover = true256            });257            return browser;...

TargetTests.cs

Source:TargetTests.cs

...43        [Fact]44        public async Task ShouldReportWhenANewPageIsCreatedAndClosed()45        {46            var otherPageTaskCompletion = new TaskCompletionSource<Page>();47            async void TargetCreatedEventHandler(object sender, TargetChangedArgs e)48            {49                otherPageTaskCompletion.SetResult(await e.Target.PageAsync());50                Browser.TargetCreated -= TargetCreatedEventHandler;51            }52            Browser.TargetCreated += TargetCreatedEventHandler;53            await Page.EvaluateFunctionHandleAsync("url => window.open(url)", TestConstants.CrossProcessUrl);54            var otherPage = await otherPageTaskCompletion.Task;55            Assert.Contains(TestConstants.CrossProcessUrl, otherPage.Url);56            Assert.Equal("Hello world", await otherPage.EvaluateExpressionAsync<string>("['Hello', 'world'].join(' ')"));57            Assert.NotNull(await otherPage.QuerySelectorAsync("body"));58            var allPages = await Browser.PagesAsync();59            Assert.Contains(Page, allPages);60            Assert.Contains(otherPage, allPages);61            var closePageTaskCompletion = new TaskCompletionSource<Page>();62            async void TargetDestroyedEventHandler(object sender, TargetChangedArgs e)63            {64                closePageTaskCompletion.SetResult(await e.Target.PageAsync());65                Browser.TargetDestroyed -= TargetDestroyedEventHandler;66            }67            Browser.TargetDestroyed += TargetDestroyedEventHandler;68            await otherPage.CloseAsync();69            Assert.Equal(otherPage, await closePageTaskCompletion.Task);70            allPages = await Task.WhenAll(Browser.Targets().Select(target => target.PageAsync()));71            Assert.Contains(Page, allPages);72            Assert.DoesNotContain(otherPage, allPages);73        }74        [Fact]75        public async Task ShouldReportWhenAServiceWorkerIsCreatedAndDestroyed()76        {77            await Page.GoToAsync(TestConstants.EmptyPage);78            var createdTargetTaskCompletion = new TaskCompletionSource<Target>();79            void TargetCreatedEventHandler(object sender, TargetChangedArgs e)80            {81                createdTargetTaskCompletion.SetResult(e.Target);82                Browser.TargetCreated -= TargetCreatedEventHandler;83            }84            Browser.TargetCreated += TargetCreatedEventHandler;85            var registration = await Page.EvaluateExpressionHandleAsync("navigator.serviceWorker.register('sw.js')");86            var createdTarget = await createdTargetTaskCompletion.Task;87            Assert.Equal("service_worker", createdTarget.Type);88            Assert.Equal(TestConstants.ServerUrl + "/sw.js", createdTarget.Url);89            var targetDestroyedTaskCompletion = new TaskCompletionSource<Target>();90            void TargetDestroyedEventHandler(object sender, TargetChangedArgs e)91            {92                targetDestroyedTaskCompletion.SetResult(e.Target);93                Browser.TargetDestroyed -= TargetDestroyedEventHandler;94            }95            Browser.TargetDestroyed += TargetDestroyedEventHandler;96            await Page.EvaluateFunctionAsync("registration => registration.unregister()", registration);97            Assert.Equal(createdTarget, await targetDestroyedTaskCompletion.Task);98        }99        [Fact]100        public async Task ShouldReportWhenATargetUrlChanges()101        {102            await Page.GoToAsync(TestConstants.EmptyPage);103            var changedTargetTaskCompletion = new TaskCompletionSource<Target>();104            void ChangedTargetEventHandler(object sender, TargetChangedArgs e)105            {106                changedTargetTaskCompletion.SetResult(e.Target);107                Browser.TargetChanged -= ChangedTargetEventHandler;108            }109            Browser.TargetChanged += ChangedTargetEventHandler;110            await Page.GoToAsync(TestConstants.CrossProcessUrl + "/");111            var changedTarget = await changedTargetTaskCompletion.Task;112            Assert.Equal(TestConstants.CrossProcessUrl + "/", changedTarget.Url);113            changedTargetTaskCompletion = new TaskCompletionSource<Target>();114            Browser.TargetChanged += ChangedTargetEventHandler;115            await Page.GoToAsync(TestConstants.EmptyPage);116            changedTarget = await changedTargetTaskCompletion.Task;117            Assert.Equal(TestConstants.EmptyPage, changedTarget.Url);118        }119        [Fact]120        public async Task ShouldNotReportUninitializedPages()121        {122            var targetChanged = false;123            EventHandler<TargetChangedArgs> listener = (sender, e) => targetChanged = true;124            Browser.TargetChanged += listener;125            var targetCompletionTask = new TaskCompletionSource<Target>();126            void TargetCreatedEventHandler(object sender, TargetChangedArgs e)127            {128                targetCompletionTask.SetResult(e.Target);129                Browser.TargetCreated -= TargetCreatedEventHandler;130            }131            Browser.TargetCreated += TargetCreatedEventHandler;132            var newPageTask = Browser.NewPageAsync();133            var target = await targetCompletionTask.Task;134            Assert.Equal(TestConstants.AboutBlank, target.Url);135            var newPage = await newPageTask;136            targetCompletionTask = new TaskCompletionSource<Target>();137            Browser.TargetCreated += TargetCreatedEventHandler;138            var evaluateTask = newPage.EvaluateExpressionHandleAsync("window.open('about:blank')");139            var target2 = await targetCompletionTask.Task;140            Assert.Equal(TestConstants.AboutBlank, target2.Url);...

BrowserContext.cs

Source:BrowserContext.cs

...21        }22        /// <summary>23        /// Raised when the url of a target changes24        /// </summary>25        public event EventHandler<TargetChangedArgs> TargetChanged;26        /// <summary>27        /// Raised when a target is created, for example when a new page is opened by <c>window.open</c> <see href="https://developer.mozilla.org/en-US/docs/Web/API/Window/open"/> or <see cref="NewPageAsync"/>.28        /// </summary>29        public event EventHandler<TargetChangedArgs> TargetCreated;30        /// <summary>31        /// Raised when a target is destroyed, for example when a page is closed32        /// </summary>33        public event EventHandler<TargetChangedArgs> TargetDestroyed;34        /// <summary>35        /// Returns whether BrowserContext is incognito36        /// The default browser context is the only non-incognito browser context37        /// </summary>38        /// <remarks>39        /// The default browser context cannot be closed40        /// </remarks>41        public bool IsIncognito => _id != null;42        /// <summary>43        /// Gets the browser this browser context belongs to44        /// </summary>45        public Browser Browser { get; }46        /// <summary>47        /// Gets an array of all active targets inside the browser context.48        /// </summary>49        /// <returns>An array of all active targets inside the browser context</returns>50        public Target[] Targets() => Array.FindAll(Browser.Targets(), target => target.BrowserContext == this);51        /// <summary>52        /// This searches for a target in this specific browser context.53        /// <example>54        /// <code>55        /// <![CDATA[56        /// await page.EvaluateAsync("() => window.open('https://www.example.com/')");57        /// var newWindowTarget = await browserContext.WaitForTargetAsync((target) => target.Url == "https://www.example.com/");58        /// ]]>59        /// </code>60        /// </example>61        /// </summary>62        /// <param name="predicate">A function to be run for every target</param>63        /// <param name="options">options</param>64        /// <returns>Resolves to the first target found that matches the predicate function.</returns>65        public Task<Target> WaitForTargetAsync(Func<Target, bool> predicate, WaitForOptions options = null)66            => Browser.WaitForTargetAsync((target) => target.BrowserContext == this && predicate(target), options);67        /// <summary>68        /// An array of all pages inside the browser context.69        /// </summary>70        /// <returns>Task which resolves to an array of all open pages.71        /// Non visible pages, such as <c>"background_page"</c>, will not be listed here.72        /// You can find them using <see cref="Target.PageAsync"/>.</returns>73        public async Task<Page[]> PagesAsync()74        => (await Task.WhenAll(75            Targets().Where(t => t.Type == TargetType.Page).Select(t => t.PageAsync())).ConfigureAwait(false))76            .Where(p => p != null).ToArray();77        /// <summary>78        /// Creates a new page79        /// </summary>80        /// <returns>Task which resolves to a new <see cref="Page"/> object</returns>81        public Task<Page> NewPageAsync() => Browser.CreatePageInContextAsync(_id);82        /// <summary>83        /// Closes the browser context. All the targets that belong to the browser context will be closed84        /// </summary>85        /// <returns>Task</returns>86        public Task CloseAsync()87        {88            if (_id == null)89            {90                throw new PuppeteerException("Non-incognito profiles cannot be closed!");91            }92            return Browser.DisposeContextAsync(_id);93        }94        /// <summary>95        /// Overrides the browser context permissions.96        /// </summary>97        /// <returns>The task.</returns>98        /// <param name="origin">The origin to grant permissions to, e.g. "https://example.com"</param>99        /// <param name="permissions">100        /// An array of permissions to grant. All permissions that are not listed here will be automatically denied.101        /// </param>102        /// <example>103        /// <![CDATA[104        /// var context = browser.DefaultBrowserContext;105        /// await context.OverridePermissionsAsync("https://html5demos.com", new List<string> {"geolocation"});106        /// ]]>107        /// </example>108        /// <seealso href="https://developer.mozilla.org/en-US/docs/Glossary/Origin"/>109        public Task OverridePermissionsAsync(string origin, IEnumerable<OverridePermission> permissions)110            => _connection.SendAsync("Browser.grantPermissions", new BrowserGrantPermissionsRequest111            {112                Origin = origin,113                BrowserContextId = _id,114                Permissions = permissions.ToArray()115            });116        /// <summary>117        /// Clears all permission overrides for the browser context.118        /// </summary>119        /// <returns>The task.</returns>120        public Task ClearPermissionOverridesAsync()121            => _connection.SendAsync("Browser.resetPermissions", new BrowserResetPermissionsRequest122            {123                BrowserContextId = _id124            });125        internal void OnTargetCreated(Browser browser, TargetChangedArgs args) => TargetCreated?.Invoke(browser, args);126        internal void OnTargetDestroyed(Browser browser, TargetChangedArgs args) => TargetDestroyed?.Invoke(browser, args);127        internal void OnTargetChanged(Browser browser, TargetChangedArgs args) => TargetChanged?.Invoke(browser, args);128    }129}...

Scraper.cs

Source:Scraper.cs

...39        }40        41        static IDisposable InterceptNewTabs(Browser browser)42        {43            async void Handler(object x, TargetChangedArgs y)44            {45                try46                {47                    var page = await y.Target.PageAsync();48                    await page.CloseAsync();49                }50                catch (PuppeteerException) { }51            }52            browser.TargetCreated += Handler;53            return new Disposable(() => browser.TargetCreated -= Handler);54        }55        static async Task<T> RetryAFewTimes<T>(Func<Task<T>> f)56        {57            const int attemptCount = 10;...

Source:Login.xaml.cs

...77            timer.Interval = TimeSpan.FromSeconds(5);78            timer.Tick += (a, b) => { ScreenShotLoginPage(); };79            timer.IsEnabled = true;80        }81        private void NavigateToQzone(object sender, PuppeteerSharp.TargetChangedArgs args)82        {83            //navigate to qzone success84            if(args.Target.Url.StartsWith(QzoneUrl.QzoneDefautUrl))85            {86                isLoginSuccess = true;87                Dispatcher.Invoke(()=> {88                    ChromiumHelper.GetChromium().RemoveTargetChangedHandler(NavigateToQzone);89                    var qq = RegexUtil.Extract(args.Target.Url, "\\d+");90                    MainWindow mainWindow = new MainWindow(qq);91                    Application.Current.MainWindow = mainWindow;92                    mainWindow.Show();93                    this.Close();94                }); 95            }...

ChromiumHelper.cs

Source:ChromiumHelper.cs

...81            }82            return null;83        }      84        85        public void SetTargetChangedHandler(EventHandler<TargetChangedArgs> eventHandler)86        {87            if(browser != null)88            {89                browser.TargetChanged += eventHandler;90            }91        }92        public void RemoveTargetChangedHandler(EventHandler<TargetChangedArgs> eventHandler)93        {94            if (browser != null)95            {96                browser.TargetChanged -= eventHandler;97            }98        }99        public async Task<string> GetHtmlSource()100        {101            if(page != null)102            {103                return await page.GetContentAsync();104            }105            return "";106        }...

TargetChangedArgs.cs

Source:TargetChangedArgs.cs

...5    /// </summary>6    /// <seealso cref="Browser.TargetChanged"/>7    /// <seealso cref="Browser.TargetCreated"/>8    /// <seealso cref="Browser.TargetDestroyed"/>9    public class TargetChangedArgs10    {11        /// <summary>12        /// Gets or sets the target info.13        /// </summary>14        /// <value>The target info.</value>15        public TargetInfo TargetInfo { get; internal set; }16        /// <summary>17        /// Gets or sets the target.18        /// </summary>19        /// <value>The target.</value>20        public Target Target { get; internal set; }21    }...

TargetChangedArgs

Using AI Code Generation

1using PuppeteerSharp;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7{8    {9        static void Main(string[] args)10        {11            var browser = Puppeteer.LaunchAsync(new LaunchOptions12            {13                Args = new string[] { "--no-sandbox" }14            }).Result;15            var page = browser.NewPageAsync().Result;16            page.TargetChanged += TargetChangedArgs;17            Console.ReadLine();18        }19        private static void TargetChangedArgs(object sender, TargetChangedArgs e)20        {21            Console.WriteLine("TargetChangedArgs");22        }23    }24}25using PuppeteerSharp;26using System;27using System.Collections.Generic;28using System.Linq;29using System.Text;30using System.Threading.Tasks;31{32    {33        static void Main(string[] args)34        {35            var browser = Puppeteer.LaunchAsync(new LaunchOptions36            {37                Args = new string[] { "--no-sandbox" }38            }).Result;39            var page = browser.NewPageAsync().Result;40            page.TargetChanged += TargetChangedArgs;41            Console.ReadLine();42        }43        private static void TargetChangedArgs(object sender, TargetChangedArgs e)44        {45            Console.WriteLine("TargetChangedArgs");46            Console.WriteLine(e.TargetInfo.Type);47            Console.WriteLine(e.TargetInfo.Url);48        }49    }50}51using PuppeteerSharp;52using System;53using System.Collections.Generic;54using System.Linq;55using System.Text;56using System.Threading.Tasks;57{58    {59        static void Main(string[] args)60        {61            var browser = Puppeteer.LaunchAsync(new LaunchOptions62            {63                Args = new string[] { "--no-sandbox" }64            }).Result;65            var page = browser.NewPageAsync().Result;66            page.TargetChanged += TargetChangedArgs;67            Console.ReadLine();68        }

TargetChangedArgs

Using AI Code Generation

1using PuppeteerSharp;2using System;3{4    {5        static async System.Threading.Tasks.Task Main(string[] args)6        {7            var browser = await Puppeteer.LaunchAsync(new LaunchOptions8            {9                Args = new string[] { "--start-maximized" }10            });11            var page = await browser.NewPageAsync();12            await page.WaitForNavigationAsync();13            await page.WaitForSelectorAsync("#tsf > div:nth-child(2) > div > div.RNNXgb > div > div.a4bIc > input");14            await page.ClickAsync("#tsf > div:nth-child(2) > div > div.RNNXgb > div > div.a4bIc > input");15            await page.WaitForNavigationAsync();16            await page.WaitForSelectorAsync("#rso > div:nth-child(1) > div > div > div > div > div > div > div > a > h3");17            await page.ClickAsync("#rso > div:nth-child(1) > div > div > div > div > div > div > div > a > h3");18            await page.WaitForNavigationAsync();19            await page.WaitForSelectorAsync("#search > div >

TargetChangedArgs

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            });11            var page = await browser.NewPageAsync();12            page.TargetChanged += Page_TargetChanged;13        }14        private static void Page_TargetChanged(object sender, TargetChangedArgs e)15        {16            Console.WriteLine("Target changed");17        }18    }19}

TargetChangedArgs

Using AI Code Generation

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static void Main(string[] args)7        {8            MainAsync().Wait();9        }10        static async Task MainAsync()11        {12            var browser = await Puppeteer.LaunchAsync(new LaunchOptions13            {14            });15            var page = await browser.NewPageAsync();16            page.TargetChanged += Page_TargetChanged;17            await page.ScreenshotAsync("google.png");18            await browser.CloseAsync();19        }20        private static void Page_TargetChanged(object sender, TargetChangedArgs e)21        {22            Console.WriteLine("TargetChanged");23        }24    }25}

TargetChangedArgs

Using AI Code Generation

1    {2        public TargetChangedArgs(TargetInfo targetInfo, string targetId)3        {4            TargetInfo = targetInfo;5            TargetId = targetId;6        }7        public TargetInfo TargetInfo { get; }8        public string TargetId { get; }9    }10    {11        public TargetInfo(string targetId, string type, string url, bool? attached)12        {13            TargetId = targetId;14            Type = type;15            Url = url;16            Attached = attached;17        }18        public string TargetId { get; }19        public string Type { get; }20        public string Url { get; }21        public bool? Attached { get; }22    }23    {24        public Target(string targetId, string type, string url, bool? attached)25        {26            TargetId = targetId;27            Type = type;28            Url = url;29            Attached = attached;30        }31        public string TargetId { get; }32        public string Type { get; }33        public string Url { get; }34        public bool? Attached { get; }35    }36    {37        public TargetEventArgs(Target target)38        {39            Target = target;40        }41        public Target Target { get; }42    }43    {44        public event EventHandler<TargetEventArgs> TargetChanged;45        public void OnTargetChanged(Target target)46        {47            TargetChanged?.Invoke(this, new TargetEventArgs(target));48        }49    }50    {51        private readonly TargetChangedHandler _targetChangedHandler;52        public TargetChangedEvent(TargetChangedHandler targetChangedHandler)53        {54            _targetChangedHandler = targetChangedHandler;55        }56        public string Name => "Target.targetCreated";57        public void Handle(JToken e)58        {59            var targetInfo = e.ToObject<TargetInfo>();60            var target = new Target(targetInfo.TargetId, targetInfo.Type, targetInfo.Url, targetInfo.Attached);61            _targetChangedHandler.OnTargetChanged(target);62        }63    }64    {65        private readonly TargetChangedHandler _targetChangedHandler;66        public TargetCreatedEvent(TargetChangedHandler targetChangedHandler)67        {

TargetChangedArgs

Using AI Code Generation

1using PuppeteerSharp;2{3    {4        public Target Target { get; set; }5    }6}7using PuppeteerSharp;8{9    {10        public async Task Example()11        {12            var browser = await Puppeteer.LaunchAsync(new LaunchOptions13            {14            });15            browser.TargetChanged += (sender, args) =>16            {

TargetChangedArgs

Using AI Code Generation

1var TargetChangedArgs = new TargetChangedArgs();2var TargetChangedArgs.TargetInfo = new TargetInfo();3var TargetChangedArgs.TargetInfo.Type = "page";4var TargetChangedArgs = new TargetChangedArgs();5var TargetChangedArgs.TargetInfo = new TargetInfo();6var TargetChangedArgs.TargetInfo.Type = "service_worker";7var TargetChangedArgs = new TargetChangedArgs();8var TargetChangedArgs.TargetInfo = new TargetInfo();9var TargetChangedArgs.TargetInfo.Type = "browser";10var TargetChangedArgs = new TargetChangedArgs();11var TargetChangedArgs.TargetInfo = new TargetInfo();12var TargetChangedArgs.TargetInfo.Type = "other";13var TargetChangedArgs = new TargetChangedArgs();14var TargetChangedArgs.TargetInfo = new TargetInfo();15var TargetChangedArgs.TargetInfo.Type = "other";16var TargetChangedArgs = new TargetChangedArgs();17var TargetChangedArgs.TargetInfo = new TargetInfo();18var TargetChangedArgs.TargetInfo.Type = "other";19var TargetChangedArgs = new TargetChangedArgs();20var TargetChangedArgs.TargetInfo = new TargetInfo();21var TargetChangedArgs.TargetInfo.Type = "other";22var TargetChangedArgs = new TargetChangedArgs();23var TargetChangedArgs.TargetInfo = new TargetInfo();24var TargetChangedArgs.TargetInfo.Type = "other";25var TargetChangedArgs = new TargetChangedArgs();26var TargetChangedArgs.TargetInfo = new TargetInfo();27var TargetChangedArgs.TargetInfo.Type = "other";28var TargetChangedArgs = new TargetChangedArgs();

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.