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

How to use ToString method of Microsoft.Playwright.Core.Locator class

Best Playwright-dotnet code snippet using Microsoft.Playwright.Core.Locator.ToString

Page.cs

Source:Page.cs

...98            };99            _channel.Console += (_, e) => Console?.Invoke(this, e);100            _channel.DOMContentLoaded += (_, _) => DOMContentLoaded?.Invoke(this, this);101            _channel.Download += (_, e) => Download?.Invoke(this, new Download(this, e.Url, e.SuggestedFilename, e.Artifact.Object));102            _channel.PageError += (_, e) => PageError?.Invoke(this, e.ToString());103            _channel.Load += (_, _) => Load?.Invoke(this, this);104            _channel.Video += (_, e) => ForceVideo().ArtifactReady(e.Artifact);105            _channel.FileChooser += (_, e) => _fileChooserEventHandler?.Invoke(this, new FileChooser(this, e.Element.Object, e.IsMultiple));106            _channel.Worker += (_, e) =>107            {108                WorkersList.Add(e.WorkerChannel.Object);109                e.WorkerChannel.Object.Page = this;110                Worker?.Invoke(this, e.WorkerChannel.Object);111            };112            _defaultNavigationTimeout = Context.DefaultNavigationTimeout;113            _defaultTimeout = Context.DefaultTimeout;114            _initializer = initializer;115            Close += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);116            Crash += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);117        }118        public event EventHandler<IConsoleMessage> Console;119        public event EventHandler<IPage> Popup;120        public event EventHandler<IRequest> Request;121        public event EventHandler<IWebSocket> WebSocket;122        public event EventHandler<IResponse> Response;123        public event EventHandler<IRequest> RequestFinished;124        public event EventHandler<IRequest> RequestFailed;125        public event EventHandler<IDialog> Dialog;126        public event EventHandler<IFrame> FrameAttached;127        public event EventHandler<IFrame> FrameDetached;128        public event EventHandler<IFrame> FrameNavigated;129        public event EventHandler<IFileChooser> FileChooser130        {131            add132            {133                lock (_fileChooserEventLock)134                {135                    _fileChooserEventHandler += value;136                    _fileChooserIntercepted = true;137                    _channel.SetFileChooserInterceptedNoReplyAsync(true).IgnoreException();138                }139            }140            remove141            {142                lock (_fileChooserEventLock)143                {144                    _fileChooserEventHandler -= value;145                    if (_fileChooserIntercepted)146                    {147                        _fileChooserIntercepted = false;148                        _channel.SetFileChooserInterceptedNoReplyAsync(false).IgnoreException();149                    }150                }151            }152        }153        public event EventHandler<IPage> Load;154        public event EventHandler<IPage> DOMContentLoaded;155        public event EventHandler<IPage> Close;156        public event EventHandler<IPage> Crash;157        public event EventHandler<string> PageError;158        public event EventHandler<IWorker> Worker;159        public event EventHandler<IDownload> Download;160        ChannelBase IChannelOwner.Channel => _channel;161        IChannel<Page> IChannelOwner<Page>.Channel => _channel;162        public bool IsClosed { get; private set; }163        IFrame IPage.MainFrame => MainFrame;164        public Frame MainFrame { get; }165        IBrowserContext IPage.Context => Context;166        public BrowserContext Context { get; set; }167        public PageViewportSizeResult ViewportSize { get; private set; }168        public IAccessibility Accessibility169        {170            get => _accessibility;171            set => throw new NotSupportedException();172        }173        public IMouse Mouse174        {175            get => _mouse;176            set => throw new NotSupportedException();177        }178        public string Url => MainFrame.Url;179        public IReadOnlyList<IFrame> Frames => _frames.AsReadOnly();180        public IKeyboard Keyboard181        {182            get => _keyboard;183        }184        public ITouchscreen Touchscreen185        {186            get => _touchscreen;187        }188        public IReadOnlyList<IWorker> Workers => WorkersList;189        public IVideo Video190        {191            get192            {193                if (Context.Options.RecordVideoDir == null)194                {195                    return null;196                }197                return ForceVideo();198            }199            set => _video = value as Video;200        }201        internal BrowserContext OwnedContext { get; set; }202        internal Dictionary<string, Delegate> Bindings { get; } = new();203        internal List<Worker> WorkersList { get; } = new();204        internal Page Opener => _initializer.Opener;205        internal PageChannel Channel => _channel;206        internal float DefaultTimeout207        {208            get => _defaultTimeout;209            set210            {211                _defaultTimeout = value;212                _channel.SetDefaultTimeoutNoReplyAsync(value).IgnoreException();213            }214        }215        internal float DefaultNavigationTimeout216        {217            get => _defaultNavigationTimeout;218            set219            {220                _defaultNavigationTimeout = value;221                _channel.SetDefaultNavigationTimeoutNoReplyAsync(value).IgnoreException();222            }223        }224        internal TaskCompletionSource<bool> ClosedOrCrashedTcs { get; } = new();225        public IFrame Frame(string name)226            => Frames.FirstOrDefault(f => f.Name == name);227        public IFrame FrameByUrl(string urlString) => Frames.FirstOrDefault(f => Context.UrlMatches(urlString, f.Url));228        public IFrame FrameByUrl(Regex urlRegex) => Frames.FirstOrDefault(f => urlRegex.IsMatch(f.Url));229        public IFrame FrameByUrl(Func<string, bool> urlFunc) => Frames.FirstOrDefault(f => urlFunc(f.Url));230        IFrameLocator IPage.FrameLocator(string selector) => MainFrame.FrameLocator(selector);231        public Task<string> TitleAsync() => MainFrame.TitleAsync();232        public Task BringToFrontAsync() => _channel.BringToFrontAsync();233        public Task<IPage> OpenerAsync() => Task.FromResult<IPage>(Opener?.IsClosed == false ? Opener : null);234        public Task EmulateMediaAsync(PageEmulateMediaOptions options = default)235        {236            var args = new Dictionary<string, object>237            {238                ["media"] = options?.Media,239                ["colorScheme"] = options?.ColorScheme,240                ["reducedMotion"] = options?.ReducedMotion,241                ["forcedColors"] = options?.ForcedColors,242            };243            return _channel.EmulateMediaAsync(args);244        }245        public Task<IResponse> GotoAsync(string url, PageGotoOptions options = default)246            => MainFrame.GotoAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout, Referer = options?.Referer });247        public Task WaitForURLAsync(string url, PageWaitForURLOptions options = default)248            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });249        public Task WaitForURLAsync(Regex url, PageWaitForURLOptions options = default)250            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });251        public Task WaitForURLAsync(Func<string, bool> url, PageWaitForURLOptions options = default)252            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });253        public Task<IConsoleMessage> WaitForConsoleMessageAsync(PageWaitForConsoleMessageOptions options = default)254            => InnerWaitForEventAsync(PageEvent.Console, null, options?.Predicate, options?.Timeout);255        public Task<IFileChooser> WaitForFileChooserAsync(PageWaitForFileChooserOptions options = default)256            => InnerWaitForEventAsync(PageEvent.FileChooser, null, options?.Predicate, options?.Timeout);257        public Task<IPage> WaitForPopupAsync(PageWaitForPopupOptions options = default)258            => InnerWaitForEventAsync(PageEvent.Popup, null, options?.Predicate, options?.Timeout);259        public Task<IWebSocket> WaitForWebSocketAsync(PageWaitForWebSocketOptions options = default)260            => InnerWaitForEventAsync(PageEvent.WebSocket, null, options?.Predicate, options?.Timeout);261        public Task<IWorker> WaitForWorkerAsync(PageWaitForWorkerOptions options = default)262            => InnerWaitForEventAsync(PageEvent.Worker, null, options?.Predicate, options?.Timeout);263        public Task<IResponse> WaitForNavigationAsync(PageWaitForNavigationOptions options = default)264            => MainFrame.WaitForNavigationAsync(new()265            {266                UrlString = options?.UrlString,267                UrlRegex = options?.UrlRegex,268                UrlFunc = options?.UrlFunc,269                WaitUntil = options?.WaitUntil,270                Timeout = options?.Timeout,271            });272        public Task<IResponse> RunAndWaitForNavigationAsync(Func<Task> action, PageRunAndWaitForNavigationOptions options = default)273            => MainFrame.RunAndWaitForNavigationAsync(action, new()274            {275                UrlString = options?.UrlString,276                UrlRegex = options?.UrlRegex,277                UrlFunc = options?.UrlFunc,278                WaitUntil = options?.WaitUntil,279                Timeout = options?.Timeout,280            });281        public Task<IRequest> WaitForRequestAsync(string urlOrPredicate, PageWaitForRequestOptions options = default)282            => InnerWaitForEventAsync(PageEvent.Request, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);283        public Task<IRequest> WaitForRequestAsync(Regex urlOrPredicate, PageWaitForRequestOptions options = default)284            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);285        public Task<IRequest> WaitForRequestAsync(Func<IRequest, bool> urlOrPredicate, PageWaitForRequestOptions options = default)286            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate(e), options?.Timeout);287        public Task<IRequest> WaitForRequestFinishedAsync(PageWaitForRequestFinishedOptions options = default)288            => InnerWaitForEventAsync(PageEvent.RequestFinished, null, options?.Predicate, options?.Timeout);289        public Task<IResponse> WaitForResponseAsync(string urlOrPredicate, PageWaitForResponseOptions options = default)290            => InnerWaitForEventAsync(PageEvent.Response, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);291        public Task<IResponse> WaitForResponseAsync(Regex urlOrPredicate, PageWaitForResponseOptions options = default)292            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);293        public Task<IResponse> WaitForResponseAsync(Func<IResponse, bool> urlOrPredicate, PageWaitForResponseOptions options = default)294            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate(e), options?.Timeout);295        public Task<IConsoleMessage> RunAndWaitForConsoleMessageAsync(Func<Task> action, PageRunAndWaitForConsoleMessageOptions options = default)296            => InnerWaitForEventAsync(PageEvent.Console, action, options?.Predicate, options?.Timeout);297        public Task<IDownload> WaitForDownloadAsync(PageWaitForDownloadOptions options = default)298            => InnerWaitForEventAsync(PageEvent.Download, null, options?.Predicate, options?.Timeout);299        public Task<IDownload> RunAndWaitForDownloadAsync(Func<Task> action, PageRunAndWaitForDownloadOptions options = default)300            => InnerWaitForEventAsync(PageEvent.Download, action, options?.Predicate, options?.Timeout);301        public Task<IFileChooser> RunAndWaitForFileChooserAsync(Func<Task> action, PageRunAndWaitForFileChooserOptions options = default)302            => InnerWaitForEventAsync(PageEvent.FileChooser, action, options?.Predicate, options?.Timeout);303        public Task<IPage> RunAndWaitForPopupAsync(Func<Task> action, PageRunAndWaitForPopupOptions options = default)304            => InnerWaitForEventAsync(PageEvent.Popup, action, options?.Predicate, options?.Timeout);305        public Task<IRequest> RunAndWaitForRequestFinishedAsync(Func<Task> action, PageRunAndWaitForRequestFinishedOptions options = default)306            => InnerWaitForEventAsync(PageEvent.RequestFinished, action, options?.Predicate, options?.Timeout);307        public Task<IWebSocket> RunAndWaitForWebSocketAsync(Func<Task> action, PageRunAndWaitForWebSocketOptions options = default)308            => InnerWaitForEventAsync(PageEvent.WebSocket, action, options?.Predicate, options?.Timeout);309        public Task<IWorker> RunAndWaitForWorkerAsync(Func<Task> action, PageRunAndWaitForWorkerOptions options = default)310            => InnerWaitForEventAsync(PageEvent.Worker, action, options?.Predicate, options?.Timeout);311        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForRequestOptions options = default)312            => InnerWaitForEventAsync(PageEvent.Request, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);313        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForRequestOptions options = default)314            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);315        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Func<IRequest, bool> urlOrPredicate, PageRunAndWaitForRequestOptions options = default)316            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate(e), options?.Timeout);317        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForResponseOptions options = default)318            => InnerWaitForEventAsync(PageEvent.Response, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);319        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForResponseOptions options = default)320            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);321        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Func<IResponse, bool> urlOrPredicate, PageRunAndWaitForResponseOptions options = default)322            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate(e), options?.Timeout);323        public Task<IJSHandle> WaitForFunctionAsync(string expression, object arg = default, PageWaitForFunctionOptions options = default)324            => MainFrame.WaitForFunctionAsync(expression, arg, new() { PollingInterval = options?.PollingInterval, Timeout = options?.Timeout });325        public async Task<T> InnerWaitForEventAsync<T>(PlaywrightEvent<T> pageEvent, Func<Task> action = default, Func<T, bool> predicate = default, float? timeout = default)326        {327            if (pageEvent == null)328            {329                throw new ArgumentException("Page event is required", nameof(pageEvent));330            }331            timeout ??= _defaultTimeout;332            using var waiter = new Waiter(this, $"page.WaitForEventAsync(\"{typeof(T)}\")");333            waiter.RejectOnTimeout(Convert.ToInt32(timeout), $"Timeout {timeout}ms exceeded while waiting for event \"{pageEvent.Name}\"");334            if (pageEvent.Name != PageEvent.Crash.Name)335            {336                waiter.RejectOnEvent<IPage>(this, PageEvent.Crash.Name, new("Page crashed"));337            }338            if (pageEvent.Name != PageEvent.Close.Name)339            {340                waiter.RejectOnEvent<IPage>(this, PageEvent.Close.Name, new("Page closed"));341            }342            var result = waiter.WaitForEventAsync(this, pageEvent.Name, predicate);343            if (action != null)344            {345                await WrapApiBoundaryAsync(() => Task.WhenAll(result, action())).ConfigureAwait(false);346            }347            return await result.ConfigureAwait(false);348        }349        public async Task CloseAsync(PageCloseOptions options = default)350        {351            try352            {353                await _channel.CloseAsync(options?.RunBeforeUnload ?? false).ConfigureAwait(false);354                if (OwnedContext != null)355                {356                    await OwnedContext.CloseAsync().ConfigureAwait(false);357                }358            }359            catch (Exception e) when (DriverMessages.IsSafeCloseError(e))360            {361                // Swallow exception362            }363        }364        public Task<T> EvaluateAsync<T>(string expression, object arg) => MainFrame.EvaluateAsync<T>(expression, arg);365        public Task<JsonElement?> EvalOnSelectorAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync(selector, expression, arg);366        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg = null, PageEvalOnSelectorOptions options = null)367            => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg, new() { Strict = options?.Strict });368        public ILocator Locator(string selector, PageLocatorOptions options = default)369            => MainFrame.Locator(selector, new() { HasTextString = options?.HasTextString, HasTextRegex = options?.HasTextRegex, Has = options?.Has });370        public Task<IElementHandle> QuerySelectorAsync(string selector, PageQuerySelectorOptions options = null)371            => MainFrame.QuerySelectorAsync(selector, new() { Strict = options?.Strict });372        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg);373        public Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync(selector, expression, arg);374        public Task<T> EvalOnSelectorAllAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync<T>(selector, expression, arg);375        public Task FillAsync(string selector, string value, PageFillOptions options = default)376            => MainFrame.FillAsync(selector, value, new() { NoWaitAfter = options?.NoWaitAfter, Timeout = options?.Timeout, Force = options?.Force, Strict = options?.Strict });377        public Task SetInputFilesAsync(string selector, string files, PageSetInputFilesOptions options = default)378            => MainFrame.SetInputFilesAsync(selector, files, Map(options));379        public Task SetInputFilesAsync(string selector, IEnumerable<string> files, PageSetInputFilesOptions options = default)380            => MainFrame.SetInputFilesAsync(selector, files, Map(options));381        public Task SetInputFilesAsync(string selector, FilePayload files, PageSetInputFilesOptions options = default)382            => MainFrame.SetInputFilesAsync(selector, files, Map(options));383        public Task SetInputFilesAsync(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions options = default)384            => MainFrame.SetInputFilesAsync(selector, files, Map(options));385        public Task TypeAsync(string selector, string text, PageTypeOptions options = default)386            => MainFrame.TypeAsync(selector, text, new()387            {388                Delay = options?.Delay,389                NoWaitAfter = options?.NoWaitAfter,390                Timeout = options?.Timeout,391                Strict = options?.Strict,392            });393        public Task FocusAsync(string selector, PageFocusOptions options = default)394            => MainFrame.FocusAsync(selector, new()395            {396                Timeout = options?.Timeout,397                Strict = options?.Strict,398            });399        public Task HoverAsync(string selector, PageHoverOptions options = default)400            => MainFrame.HoverAsync(401                selector,402                new()403                {404                    Position = options?.Position,405                    Modifiers = options?.Modifiers,406                    Force = options?.Force,407                    Timeout = options?.Timeout,408                    Trial = options?.Trial,409                    Strict = options?.Strict,410                });411        public Task PressAsync(string selector, string key, PagePressOptions options = default)412            => MainFrame.PressAsync(selector, key, new()413            {414                Delay = options?.Delay,415                NoWaitAfter = options?.NoWaitAfter,416                Timeout = options?.Timeout,417                Strict = options?.Strict,418            });419        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, string values, PageSelectOptionOptions options = default)420            => SelectOptionAsync(selector, new[] { values }, options);421        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<string> values, PageSelectOptionOptions options = default)422            => SelectOptionAsync(selector, values.Select(x => new SelectOptionValue() { Value = x }), options);423        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IElementHandle values, PageSelectOptionOptions options = default)424            => SelectOptionAsync(selector, new[] { values }, options);425        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<IElementHandle> values, PageSelectOptionOptions options = default)426            => MainFrame.SelectOptionAsync(selector, values, new()427            {428                NoWaitAfter = options?.NoWaitAfter,429                Timeout = options?.Timeout,430                Force = options?.Force,431                Strict = options?.Strict,432            });433        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, SelectOptionValue values, PageSelectOptionOptions options = default)434            => SelectOptionAsync(selector, new[] { values }, options);435        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<SelectOptionValue> values, PageSelectOptionOptions options = default)436            => MainFrame.SelectOptionAsync(selector, values, new()437            {438                NoWaitAfter = options?.NoWaitAfter,439                Timeout = options?.Timeout,440                Force = options?.Force,441                Strict = options?.Strict,442            });443        public Task WaitForTimeoutAsync(float timeout) => MainFrame.WaitForTimeoutAsync(timeout);444        public Task<IElementHandle> WaitForSelectorAsync(string selector, PageWaitForSelectorOptions options = default)445            => MainFrame.WaitForSelectorAsync(selector, new()446            {447                State = options?.State,448                Timeout = options?.Timeout,449                Strict = options?.Strict,450            });451        public Task<JsonElement?> EvaluateAsync(string expression, object arg) => MainFrame.EvaluateAsync(expression, arg);452        public async Task<byte[]> ScreenshotAsync(PageScreenshotOptions options = default)453        {454            options ??= new PageScreenshotOptions();455            if (options.Type == null && !string.IsNullOrEmpty(options.Path))456            {457                options.Type = ElementHandle.DetermineScreenshotType(options.Path);458            }459            byte[] result = await _channel.ScreenshotAsync(460                path: options.Path,461                fullPage: options.FullPage,462                clip: options.Clip,463                omitBackground: options.OmitBackground,464                type: options.Type,465                quality: options.Quality,466                mask: options.Mask,467                animations: options.Animations,468                caret: options.Caret,469                scale: options.Scale,470                timeout: options.Timeout).ConfigureAwait(false);471            if (!string.IsNullOrEmpty(options.Path))472            {473                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);474                File.WriteAllBytes(options.Path, result);475            }476            return result;477        }478        public Task SetContentAsync(string html, PageSetContentOptions options = default)479            => MainFrame.SetContentAsync(html, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });480        public Task<string> ContentAsync() => MainFrame.ContentAsync();481        public Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)482            => _channel.SetExtraHTTPHeadersAsync(headers);483        public Task<IElementHandle> QuerySelectorAsync(string selector) => MainFrame.QuerySelectorAsync(selector);484        public Task<IReadOnlyList<IElementHandle>> QuerySelectorAllAsync(string selector)485            => MainFrame.QuerySelectorAllAsync(selector);486        public Task<IJSHandle> EvaluateHandleAsync(string expression, object arg) => MainFrame.EvaluateHandleAsync(expression, arg);487        public Task<IElementHandle> AddScriptTagAsync(PageAddScriptTagOptions options = default)488            => MainFrame.AddScriptTagAsync(new()489            {490                Url = options?.Url,491                Path = options?.Path,492                Content = options?.Content,493                Type = options?.Type,494            });495        public Task<IElementHandle> AddStyleTagAsync(PageAddStyleTagOptions options = default)496            => MainFrame.AddStyleTagAsync(new()497            {498                Url = options?.Url,499                Path = options?.Path,500                Content = options?.Content,501            });502        public Task ClickAsync(string selector, PageClickOptions options = default)503            => MainFrame.ClickAsync(504                selector,505                new()506                {507                    Button = options?.Button,508                    ClickCount = options?.ClickCount,509                    Delay = options?.Delay,510                    Position = options?.Position,511                    Modifiers = options?.Modifiers,512                    Force = options?.Force,513                    NoWaitAfter = options?.NoWaitAfter,514                    Timeout = options?.Timeout,515                    Trial = options?.Trial,516                    Strict = options?.Strict,517                });518        public Task DblClickAsync(string selector, PageDblClickOptions options = default)519            => MainFrame.DblClickAsync(selector, new()520            {521                Delay = options?.Delay,522                Button = options?.Button,523                Position = options?.Position,524                Modifiers = options?.Modifiers,525                Timeout = options?.Timeout,526                Force = options?.Force,527                NoWaitAfter = options?.NoWaitAfter,528                Trial = options?.Trial,529                Strict = options?.Strict,530            });531        public async Task<IResponse> GoBackAsync(PageGoBackOptions options = default)532            => (await _channel.GoBackAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;533        public async Task<IResponse> GoForwardAsync(PageGoForwardOptions options = default)534            => (await _channel.GoForwardAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;535        public async Task<IResponse> ReloadAsync(PageReloadOptions options = default)536            => (await _channel.ReloadAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;537        public Task ExposeBindingAsync(string name, Action callback, PageExposeBindingOptions options = default)538            => InnerExposeBindingAsync(name, (Delegate)callback, options?.Handle ?? false);539        public Task ExposeBindingAsync(string name, Action<BindingSource> callback)540            => InnerExposeBindingAsync(name, (Delegate)callback);541        public Task ExposeBindingAsync<T>(string name, Action<BindingSource, T> callback)542            => InnerExposeBindingAsync(name, (Delegate)callback);543        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, TResult> callback)544            => InnerExposeBindingAsync(name, (Delegate)callback);545        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, IJSHandle, TResult> callback)546            => InnerExposeBindingAsync(name, (Delegate)callback, true);547        public Task ExposeBindingAsync<T, TResult>(string name, Func<BindingSource, T, TResult> callback)548            => InnerExposeBindingAsync(name, (Delegate)callback);549        public Task ExposeBindingAsync<T1, T2, TResult>(string name, Func<BindingSource, T1, T2, TResult> callback)550            => InnerExposeBindingAsync(name, (Delegate)callback);551        public Task ExposeBindingAsync<T1, T2, T3, TResult>(string name, Func<BindingSource, T1, T2, T3, TResult> callback)552            => InnerExposeBindingAsync(name, (Delegate)callback);553        public Task ExposeBindingAsync<T1, T2, T3, T4, TResult>(string name, Func<BindingSource, T1, T2, T3, T4, TResult> callback)554            => InnerExposeBindingAsync(name, (Delegate)callback);555        public Task ExposeFunctionAsync(string name, Action callback)556            => ExposeBindingAsync(name, (BindingSource _) => callback());557        public Task ExposeFunctionAsync<T>(string name, Action<T> callback)558            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));559        public Task ExposeFunctionAsync<TResult>(string name, Func<TResult> callback)560            => ExposeBindingAsync(name, (BindingSource _) => callback());561        public Task ExposeFunctionAsync<T, TResult>(string name, Func<T, TResult> callback)562            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));563        public Task ExposeFunctionAsync<T1, T2, TResult>(string name, Func<T1, T2, TResult> callback)564            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2) => callback(t1, t2));565        public Task ExposeFunctionAsync<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> callback)566            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3) => callback(t1, t2, t3));567        public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> callback)568            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3, T4 t4) => callback(t1, t2, t3, t4));569        public async Task<byte[]> PdfAsync(PagePdfOptions options = default)570        {571            if (!Context.IsChromium)572            {573                throw new NotSupportedException("This browser doesn't support this action.");574            }575            byte[] result = await _channel.PdfAsync(576                scale: options?.Scale,577                displayHeaderFooter: options?.DisplayHeaderFooter,578                headerTemplate: options?.HeaderTemplate,579                footerTemplate: options?.FooterTemplate,580                printBackground: options?.PrintBackground,581                landscape: options?.Landscape,582                pageRanges: options?.PageRanges,583                format: options?.Format,584                width: options?.Width,585                height: options?.Height,586                margin: options?.Margin,587                preferCSSPageSize: options?.PreferCSSPageSize).ConfigureAwait(false);588            if (!string.IsNullOrEmpty(options?.Path))589            {590                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);591                File.WriteAllBytes(options.Path, result);592            }593            return result;594        }595        public Task AddInitScriptAsync(string script, string scriptPath)596            => _channel.AddInitScriptAsync(ScriptsHelper.EvaluationScript(script, scriptPath));597        public Task RouteAsync(string url, Action<IRoute> handler, PageRouteOptions options = null)598            => RouteAsync(new Regex(Context.CombineUrlWithBase(url).GlobToRegex()), null, handler, options);599        public Task RouteAsync(Regex url, Action<IRoute> handler, PageRouteOptions options = null)600             => RouteAsync(url, null, handler, options);601        public Task RouteAsync(Func<string, bool> url, Action<IRoute> handler, PageRouteOptions options = null)602            => RouteAsync(null, url, handler, options);603        public Task UnrouteAsync(string urlString, Action<IRoute> handler)604            => UnrouteAsync(new Regex(Context.CombineUrlWithBase(urlString).GlobToRegex()), null, handler);605        public Task UnrouteAsync(Regex urlString, Action<IRoute> handler)606            => UnrouteAsync(urlString, null, handler);607        public Task UnrouteAsync(Func<string, bool> urlFunc, Action<IRoute> handler)608            => UnrouteAsync(null, urlFunc, handler);609        public Task WaitForLoadStateAsync(LoadState? state = default, PageWaitForLoadStateOptions options = default)610            => MainFrame.WaitForLoadStateAsync(state, new() { Timeout = options?.Timeout });611        public Task SetViewportSizeAsync(int width, int height)612        {613            ViewportSize = new() { Width = width, Height = height };614            return _channel.SetViewportSizeAsync(ViewportSize);615        }616        public Task SetCheckedAsync(string selector, bool checkedState, PageSetCheckedOptions options = null)617            => checkedState ?618            MainFrame.CheckAsync(selector, new()619            {620                Position = options?.Position,621                Force = options?.Force,622                NoWaitAfter = options?.NoWaitAfter,623                Strict = options?.Strict,624                Timeout = options?.Timeout,625                Trial = options?.Trial,626            })627            : MainFrame.UncheckAsync(selector, new()628            {629                Position = options?.Position,630                Force = options?.Force,631                NoWaitAfter = options?.NoWaitAfter,632                Timeout = options?.Timeout,633                Trial = options?.Trial,634                Strict = options?.Strict,635            });636        public Task CheckAsync(string selector, PageCheckOptions options = default)637            => MainFrame.CheckAsync(selector, new()638            {639                Position = options?.Position,640                Force = options?.Force,641                NoWaitAfter = options?.NoWaitAfter,642                Strict = options?.Strict,643                Timeout = options?.Timeout,644                Trial = options?.Trial,645            });646        public Task UncheckAsync(string selector, PageUncheckOptions options = default)647            => MainFrame.UncheckAsync(selector, new()648            {649                Position = options?.Position,650                Force = options?.Force,651                NoWaitAfter = options?.NoWaitAfter,652                Timeout = options?.Timeout,653                Trial = options?.Trial,654                Strict = options?.Strict,655            });656        public Task DispatchEventAsync(string selector, string type, object eventInit = default, PageDispatchEventOptions options = default)657             => MainFrame.DispatchEventAsync(selector, type, eventInit, new() { Timeout = options?.Timeout, Strict = options?.Strict });658        public Task<string> GetAttributeAsync(string selector, string name, PageGetAttributeOptions options = default)659             => MainFrame.GetAttributeAsync(selector, name, new()660             {661                 Timeout = options?.Timeout,662                 Strict = options?.Strict,663             });664        public Task<string> InnerHTMLAsync(string selector, PageInnerHTMLOptions options = default)665             => MainFrame.InnerHTMLAsync(selector, new()666             {667                 Timeout = options?.Timeout,668                 Strict = options?.Strict,669             });670        public Task<string> InnerTextAsync(string selector, PageInnerTextOptions options = default)671             => MainFrame.InnerTextAsync(selector, new()672             {673                 Timeout = options?.Timeout,674                 Strict = options?.Strict,675             });676        public Task<string> TextContentAsync(string selector, PageTextContentOptions options = default)677             => MainFrame.TextContentAsync(selector, new()678             {679                 Timeout = options?.Timeout,680                 Strict = options?.Strict,681             });682        public Task TapAsync(string selector, PageTapOptions options = default)683            => MainFrame.TapAsync(684                selector,685                new()686                {687                    Modifiers = options?.Modifiers,688                    Position = options?.Position,689                    Force = options?.Force,690                    NoWaitAfter = options?.NoWaitAfter,691                    Timeout = options?.Timeout,692                    Trial = options?.Trial,693                    Strict = options?.Strict,694                });695        public Task<bool> IsCheckedAsync(string selector, PageIsCheckedOptions options = default)696            => MainFrame.IsCheckedAsync(selector, new()697            {698                Timeout = options?.Timeout,699                Strict = options?.Strict,700            });701        public Task<bool> IsDisabledAsync(string selector, PageIsDisabledOptions options = default)702            => MainFrame.IsDisabledAsync(selector, new()703            {704                Timeout = options?.Timeout,705                Strict = options?.Strict,706            });707        public Task<bool> IsEditableAsync(string selector, PageIsEditableOptions options = default)708            => MainFrame.IsEditableAsync(selector, new()709            {710                Timeout = options?.Timeout,711                Strict = options?.Strict,712            });713        public Task<bool> IsEnabledAsync(string selector, PageIsEnabledOptions options = default)714            => MainFrame.IsEnabledAsync(selector, new()715            {716                Timeout = options?.Timeout,717                Strict = options?.Strict,718            });719#pragma warning disable CS0612 // Type or member is obsolete720        public Task<bool> IsHiddenAsync(string selector, PageIsHiddenOptions options = default)721            => MainFrame.IsHiddenAsync(selector, new()722            {723                Timeout = options?.Timeout,724                Strict = options?.Strict,725            });726        public Task<bool> IsVisibleAsync(string selector, PageIsVisibleOptions options = default)727            => MainFrame.IsVisibleAsync(selector, new()728            {729                Timeout = options?.Timeout,730                Strict = options?.Strict,731            });732#pragma warning restore CS0612 // Type or member is obsolete733        public Task PauseAsync() => Context.Channel.PauseAsync();734        public void SetDefaultNavigationTimeout(float timeout) => DefaultNavigationTimeout = timeout;735        public void SetDefaultTimeout(float timeout) => DefaultTimeout = timeout;736        public Task<string> InputValueAsync(string selector, PageInputValueOptions options = null)737            => MainFrame.InputValueAsync(selector, new()738            {739                Timeout = options?.Timeout,740                Strict = options?.Strict,741            });742        public Task DragAndDropAsync(string source, string target, PageDragAndDropOptions options = null)743            => MainFrame.DragAndDropAsync(source, target, new()744            {745                Force = options?.Force,746                NoWaitAfter = options?.NoWaitAfter,747                Timeout = options?.Timeout,748                Trial = options?.Trial,749                Strict = options?.Strict,750            });751        internal void NotifyPopup(Page page) => Popup?.Invoke(this, page);752        internal void OnFrameNavigated(Frame frame)753            => FrameNavigated?.Invoke(this, frame);754        internal void FireRequest(IRequest request) => Request?.Invoke(this, request);755        internal void FireRequestFailed(IRequest request) => RequestFailed?.Invoke(this, request);756        internal void FireRequestFinished(IRequest request) => RequestFinished?.Invoke(this, request);757        internal void FireResponse(IResponse response) => Response?.Invoke(this, response);758        private Task RouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler, PageRouteOptions options)759            => RouteAsync(new()760            {761                Regex = urlRegex,762                Function = urlFunc,763                Handler = handler,764                Times = options?.Times,765            });766        private Task RouteAsync(RouteSetting setting)767        {768            _routes.Insert(0, setting);769            if (_routes.Count == 1)770            {771                return _channel.SetNetworkInterceptionEnabledAsync(true);772            }773            return Task.CompletedTask;774        }775        private Task UnrouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler = null)776            => UnrouteAsync(new()777            {778                Function = urlFunc,779                Regex = urlRegex,780                Handler = handler,781            });782        private Task UnrouteAsync(RouteSetting setting)783        {784            var newRoutesList = new List<RouteSetting>();785            newRoutesList.AddRange(_routes.Where(r =>786                (setting.Regex != null && !(r.Regex == setting.Regex || (r.Regex.ToString() == setting.Regex.ToString() && r.Regex.Options == setting.Regex.Options))) ||787                (setting.Function != null && r.Function != setting.Function) ||788                (setting.Handler != null && r.Handler != setting.Handler)));789            _routes = newRoutesList;790            if (_routes.Count == 0)791            {792                return DisableInterceptionAsync();793            }794            return Task.CompletedTask;795        }796        internal void OnClose()797        {798            IsClosed = true;799            Context?.PagesList.Remove(this);800            RejectPendingOperations(false);...

ElementHandleChannel.cs

Source:ElementHandleChannel.cs

...44        {45            switch (method)46            {47                case "previewUpdated":48                    PreviewUpdated?.Invoke(this, new() { Preview = serverParams.Value.GetProperty("preview").ToString() });49                    break;50            }51        }52        internal Task<ElementHandleChannel> WaitForSelectorAsync(string selector, WaitForSelectorState? state, float? timeout, bool? strict)53        {54            var args = new Dictionary<string, object>55            {56                ["selector"] = selector,57                ["timeout"] = timeout,58                ["state"] = state,59                ["strict"] = strict,60            };61            return Connection.SendMessageToServerAsync<ElementHandleChannel>(62                Guid,63                "waitForSelector",64                args);65        }66        internal Task<ElementHandleChannel> QuerySelectorAsync(string selector)67            => Connection.SendMessageToServerAsync<ElementHandleChannel>(68                Guid,69                "querySelector",70                new Dictionary<string, object>71                {72                    ["selector"] = selector,73                });74        internal Task WaitForElementStateAsync(ElementState state, float? timeout)75        {76            var args = new Dictionary<string, object>77            {78                ["state"] = state,79                ["timeout"] = timeout,80            };81            return Connection.SendMessageToServerAsync<ElementHandleChannel>(Guid, "waitForElementState", args);82        }83        internal Task<ChannelBase[]> QuerySelectorAllAsync(string selector)84            => Connection.SendMessageToServerAsync<ChannelBase[]>(85                Guid,86                "querySelectorAll",87                new Dictionary<string, object>88                {89                    ["selector"] = selector,90                });91        internal async Task<byte[]> ScreenshotAsync(string path, bool? omitBackground, ScreenshotType? type, int? quality, IEnumerable<ILocator> mask, ScreenshotAnimations? animations, ScreenshotCaret? caret, ScreenshotScale? scale, float? timeout)92        {93            var args = new Dictionary<string, object>94            {95                ["type"] = type,96                ["omitBackground"] = omitBackground,97                ["path"] = path,98                ["timeout"] = timeout,99                ["animations"] = animations,100                ["caret"] = caret,101                ["scale"] = scale,102                ["quality"] = quality,103            };104            if (mask != null)105            {106                args["mask"] = mask.Select(locator => new Dictionary<string, object>107                {108                    ["frame"] = ((Locator)locator)._frame._channel,109                    ["selector"] = ((Locator)locator)._selector,110                }).ToArray();111            }112            return (await Connection.SendMessageToServerAsync(Guid, "screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();113        }114        internal Task<JsonElement?> EvalOnSelectorAsync(string selector, string script, object arg)115            => Connection.SendMessageToServerAsync<JsonElement?>(116                Guid,117                "evalOnSelector",118                new Dictionary<string, object>119                {120                    ["selector"] = selector,121                    ["expression"] = script,122                    ["arg"] = arg,123                });124        internal Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string script, object arg)125            => Connection.SendMessageToServerAsync<JsonElement?>(126                Guid,127                "evalOnSelectorAll",128                new Dictionary<string, object>129                {130                    ["selector"] = selector,131                    ["expression"] = script,132                    ["arg"] = arg,133                });134        internal Task<FrameChannel> ContentFrameAsync() => Connection.SendMessageToServerAsync<FrameChannel>(Guid, "contentFrame", null);135        internal Task<FrameChannel> OwnerFrameAsync() => Connection.SendMessageToServerAsync<FrameChannel>(Guid, "ownerFrame", null);136        internal Task HoverAsync(137            IEnumerable<KeyboardModifier> modifiers,138            Position position,139            float? timeout,140            bool? force,141            bool? trial)142        {143            var args = new Dictionary<string, object>144            {145                ["force"] = force,146                ["position"] = position,147                ["timeout"] = timeout,148                ["trial"] = trial,149                ["modifiers"] = modifiers?.Select(m => m.ToValueString()),150            };151            return Connection.SendMessageToServerAsync<JsonElement?>(Guid, "hover", args);152        }153        internal Task FocusAsync() => Connection.SendMessageToServerAsync(Guid, "focus", null);154        internal Task ClickAsync(155            float? delay,156            MouseButton? button,157            int? clickCount,158            IEnumerable<KeyboardModifier> modifiers,159            Position position,160            float? timeout,161            bool? force,162            bool? noWaitAfter,163            bool? trial)164        {165            var args = new Dictionary<string, object>166            {167                ["delay"] = delay,168                ["button"] = button,169                ["clickCount"] = clickCount,170                ["force"] = force,171                ["noWaitAfter"] = noWaitAfter,172                ["timeout"] = timeout,173                ["trial"] = trial,174                ["position"] = position,175                ["modifiers"] = modifiers?.Select(m => m.ToValueString()),176            };177            return Connection.SendMessageToServerAsync(Guid, "click", args);178        }179        internal Task DblClickAsync(180            float? delay,181            MouseButton? button,182            IEnumerable<KeyboardModifier> modifiers,183            Position position,184            float? timeout,185            bool? force,186            bool? noWaitAfter,187            bool? trial)188        {189            var args = new Dictionary<string, object>190            {191                ["delay"] = delay,192                ["button"] = button,193                ["force"] = force,194                ["noWaitAfter"] = noWaitAfter,195                ["timeout"] = timeout,196                ["trial"] = trial,197                ["position"] = position,198                ["modifiers"] = modifiers?.Select(m => m.ToValueString()),199            };200            return Connection.SendMessageToServerAsync(Guid, "dblclick", args);201        }202        internal async Task<ElementHandleBoundingBoxResult> BoundingBoxAsync()203        {204            var result = (await Connection.SendMessageToServerAsync(Guid, "boundingBox", null).ConfigureAwait(false)).Value;205            if (result.TryGetProperty("value", out var value))206            {207                return value.ToObject<ElementHandleBoundingBoxResult>();208            }209            return null;210        }211        internal Task ScrollIntoViewIfNeededAsync(float? timeout)212        {213            var args = new Dictionary<string, object>214            {215                ["timeout"] = timeout,216            };217            return Connection.SendMessageToServerAsync<ElementHandleChannel>(Guid, "scrollIntoViewIfNeeded", args);218        }219        internal Task FillAsync(string value, bool? noWaitAfter, bool? force, float? timeout)220        {221            var args = new Dictionary<string, object>222            {223                ["value"] = value,224                ["timeout"] = timeout,225                ["force"] = force,226                ["noWaitAfter"] = noWaitAfter,227            };228            return Connection.SendMessageToServerAsync(Guid, "fill", args);229        }230        internal Task DispatchEventAsync(string type, object eventInit)231        {232            var args = new Dictionary<string, object>233            {234                ["type"] = type,235                ["eventInit"] = eventInit,236            };237            return Connection.SendMessageToServerAsync<ElementHandleChannel>(Guid, "dispatchEvent", args);238        }239        internal Task SetInputFilesAsync(IEnumerable<InputFilesList> files, bool? noWaitAfter, float? timeout)240        {241            var args = new Dictionary<string, object>242            {243                ["files"] = files,244                ["timeout"] = timeout,245                ["noWaitAfter"] = noWaitAfter,246            };247            return Connection.SendMessageToServerAsync(Guid, "setInputFiles", args);248        }249        internal Task SetInputFilePathsAsync(IEnumerable<string> localPaths, IEnumerable<WritableStream> streams, bool? noWaitAfter, float? timeout)250        {251            var args = new Dictionary<string, object>252            {253                ["localPaths"] = localPaths,254                ["streams"] = streams,255                ["timeout"] = timeout,256                ["noWaitAfter"] = noWaitAfter,257            };258            return Connection.SendMessageToServerAsync(Guid, "setInputFilePaths", args);259        }260        internal async Task<string> GetAttributeAsync(string name)261        {262            var args = new Dictionary<string, object>263            {264                ["name"] = name,265            };266            return (await Connection.SendMessageToServerAsync(Guid, "getAttribute", args).ConfigureAwait(false))?.GetProperty("value").ToString();267        }268        internal async Task<string> InnerHTMLAsync()269            => (await Connection.SendMessageToServerAsync(Guid, "innerHTML").ConfigureAwait(false))?.GetProperty("value").ToString();270        internal async Task<string> InnerTextAsync()271            => (await Connection.SendMessageToServerAsync(Guid, "innerText").ConfigureAwait(false))?.GetProperty("value").ToString();272        internal async Task<string> TextContentAsync()273            => (await Connection.SendMessageToServerAsync(Guid, "textContent").ConfigureAwait(false))?.GetProperty("value").ToString();274        internal Task SelectTextAsync(bool? force = null, float? timeout = null)275        {276            var args = new Dictionary<string, object>277            {278                ["force"] = force,279                ["timeout"] = timeout,280            };281            return Connection.SendMessageToServerAsync<ElementHandleChannel>(Guid, "selectText", args);282        }283        internal async Task<IReadOnlyList<string>> SelectOptionAsync(object values, bool? noWaitAfter = null, bool? force = null, float? timeout = null)284        {285            var args = new Dictionary<string, object>();286            if (values is IElementHandle[])287            {...

Locator.cs

Source:Locator.cs

...42            _selector = selector;43            _options = options;44            if (options?.HasTextRegex != null)45            {46                _selector += $" >> :scope:text-matches({options.HasTextRegex.ToString().EscapeWithQuotes("\"")}, {options.HasTextRegex.Options.GetInlineFlags().EscapeWithQuotes("\"")})";47            }48            if (options?.HasTextString != null)49            {50                _selector += $" >> :scope:has-text({options.HasTextString.EscapeWithQuotes("\"")})";51            }52            if (options?.Has != null)53            {54                var has = (Locator)options.Has;55                if (has._frame != _frame)56                {57                    throw new ArgumentException("Inner \"has\" locator must belong to the same frame.");58                }59                _selector += " >> has=" + JsonSerializer.Serialize(has._selector);60            }61        }62        public ILocator First => new Locator(_frame, $"{_selector} >> nth=0");63        public ILocator Last => new Locator(_frame, $"{_selector} >> nth=-1");64        IPage ILocator.Page => _frame.Page;65        public async Task<IReadOnlyList<string>> AllInnerTextsAsync()66            => await EvaluateAllAsync<string[]>("ee => ee.map(e => e.innerText)").ConfigureAwait(false);67        public async Task<IReadOnlyList<string>> AllTextContentsAsync()68            => await EvaluateAllAsync<string[]>("ee => ee.map(e => e.textContent || '')").ConfigureAwait(false);69        public async Task<LocatorBoundingBoxResult> BoundingBoxAsync(LocatorBoundingBoxOptions options = null)70            => await WithElementAsync(71                async (h, _) =>72                {73                    var bb = await h.BoundingBoxAsync().ConfigureAwait(false);74                    if (bb == null)75                    {76                        return null;77                    }78                    return new LocatorBoundingBoxResult()79                    {80                        Height = bb.Height,81                        Width = bb.Width,82                        X = bb.X,83                        Y = bb.Y,84                    };85                },86                options).ConfigureAwait(false);87        public Task CheckAsync(LocatorCheckOptions options = null)88            => _frame.CheckAsync(89                _selector,90                ConvertOptions<FrameCheckOptions>(options));91        public Task ClickAsync(LocatorClickOptions options = null)92            => _frame.ClickAsync(93                _selector,94                ConvertOptions<FrameClickOptions>(options));95        public Task SetCheckedAsync(bool checkedState, LocatorSetCheckedOptions options = null)96            => checkedState ?97                CheckAsync(ConvertOptions<LocatorCheckOptions>(options))98                : UncheckAsync(ConvertOptions<LocatorUncheckOptions>(options));99        public Task<int> CountAsync()100            => _frame.QueryCountAsync(_selector);101        public Task DblClickAsync(LocatorDblClickOptions options = null)102            => _frame.DblClickAsync(_selector, ConvertOptions<FrameDblClickOptions>(options));103        public Task DispatchEventAsync(string type, object eventInit = null, LocatorDispatchEventOptions options = null)104            => _frame.DispatchEventAsync(_selector, type, eventInit, ConvertOptions<FrameDispatchEventOptions>(options));105        public Task DragToAsync(ILocator target, LocatorDragToOptions options = null)106            => _frame.DragAndDropAsync(_selector, ((Locator)target)._selector, ConvertOptions<FrameDragAndDropOptions>(options));107        public async Task<IElementHandle> ElementHandleAsync(LocatorElementHandleOptions options = null)108            => await _frame.WaitForSelectorAsync(109                _selector,110                ConvertOptions<FrameWaitForSelectorOptions>(options)).ConfigureAwait(false);111        public Task<IReadOnlyList<IElementHandle>> ElementHandlesAsync()112            => _frame.QuerySelectorAllAsync(_selector);113        public Task<T> EvaluateAllAsync<T>(string expression, object arg = null)114            => _frame.EvalOnSelectorAllAsync<T>(_selector, expression, arg);115        public Task<JsonElement?> EvaluateAsync(string expression, object arg = null, LocatorEvaluateOptions options = null)116            => EvaluateAsync<JsonElement?>(expression, arg, options);117        public Task<T> EvaluateAsync<T>(string expression, object arg = null, LocatorEvaluateOptions options = null)118            => _frame.EvalOnSelectorAsync<T>(_selector, expression, arg, ConvertOptions<FrameEvalOnSelectorOptions>(options));119        public async Task<IJSHandle> EvaluateHandleAsync(string expression, object arg = null, LocatorEvaluateHandleOptions options = null)120            => await WithElementAsync(async (e, _) => await e.EvaluateHandleAsync(expression, arg).ConfigureAwait(false), options).ConfigureAwait(false);121        public async Task FillAsync(string value, LocatorFillOptions options = null)122            => await _frame.FillAsync(_selector, value, ConvertOptions<FrameFillOptions>(options)).ConfigureAwait(false);123        public Task FocusAsync(LocatorFocusOptions options = null)124            => _frame.FocusAsync(_selector, ConvertOptions<FrameFocusOptions>(options));125        IFrameLocator ILocator.FrameLocator(string selector) =>126            new FrameLocator(_frame, $"{_selector} >> {selector}");127        public Task<string> GetAttributeAsync(string name, LocatorGetAttributeOptions options = null)128            => _frame.GetAttributeAsync(_selector, name, ConvertOptions<FrameGetAttributeOptions>(options));129        public Task HoverAsync(LocatorHoverOptions options = null)130            => _frame.HoverAsync(_selector, ConvertOptions<FrameHoverOptions>(options));131        public Task<string> InnerHTMLAsync(LocatorInnerHTMLOptions options = null)132            => _frame.InnerHTMLAsync(_selector, ConvertOptions<FrameInnerHTMLOptions>(options));133        public Task<string> InnerTextAsync(LocatorInnerTextOptions options = null)134            => _frame.InnerTextAsync(_selector, ConvertOptions<FrameInnerTextOptions>(options));135        public Task<string> InputValueAsync(LocatorInputValueOptions options = null)136            => _frame.InputValueAsync(_selector, ConvertOptions<FrameInputValueOptions>(options));137        public Task<bool> IsCheckedAsync(LocatorIsCheckedOptions options = null)138            => _frame.IsCheckedAsync(_selector, ConvertOptions<FrameIsCheckedOptions>(options));139        public Task<bool> IsDisabledAsync(LocatorIsDisabledOptions options = null)140            => _frame.IsDisabledAsync(_selector, ConvertOptions<FrameIsDisabledOptions>(options));141        public Task<bool> IsEditableAsync(LocatorIsEditableOptions options = null)142            => _frame.IsEditableAsync(_selector, ConvertOptions<FrameIsEditableOptions>(options));143        public Task<bool> IsEnabledAsync(LocatorIsEnabledOptions options = null)144            => _frame.IsEnabledAsync(_selector, ConvertOptions<FrameIsEnabledOptions>(options));145        public Task<bool> IsHiddenAsync(LocatorIsHiddenOptions options = null)146            => _frame.IsHiddenAsync(_selector, ConvertOptions<FrameIsHiddenOptions>(options));147        public Task<bool> IsVisibleAsync(LocatorIsVisibleOptions options = null)148            => _frame.IsVisibleAsync(_selector, ConvertOptions<FrameIsVisibleOptions>(options));149        public ILocator Nth(int index)150            => new Locator(_frame, $"{_selector} >> nth={index}");151        public Task PressAsync(string key, LocatorPressOptions options = null)152            => _frame.PressAsync(_selector, key, ConvertOptions<FramePressOptions>(options));153        public Task<byte[]> ScreenshotAsync(LocatorScreenshotOptions options = null)154            => WithElementAsync(async (h, o) => await h.ScreenshotAsync(ConvertOptions<ElementHandleScreenshotOptions>(o)).ConfigureAwait(false), options);155        public Task ScrollIntoViewIfNeededAsync(LocatorScrollIntoViewIfNeededOptions options = null)156            => WithElementAsync(async (h, o) => await h.ScrollIntoViewIfNeededAsync(ConvertOptions<ElementHandleScrollIntoViewIfNeededOptions>(o)).ConfigureAwait(false), options);157        public Task<IReadOnlyList<string>> SelectOptionAsync(string values, LocatorSelectOptionOptions options = null)158            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));159        public Task<IReadOnlyList<string>> SelectOptionAsync(IElementHandle values, LocatorSelectOptionOptions options = null)160            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));161        public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<string> values, LocatorSelectOptionOptions options = null)162            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));163        public Task<IReadOnlyList<string>> SelectOptionAsync(SelectOptionValue values, LocatorSelectOptionOptions options = null)164            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));165        public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<IElementHandle> values, LocatorSelectOptionOptions options = null)166            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));167        public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<SelectOptionValue> values, LocatorSelectOptionOptions options = null)168            => _frame.SelectOptionAsync(_selector, values, ConvertOptions<FrameSelectOptionOptions>(options));169        public Task SelectTextAsync(LocatorSelectTextOptions options = null)170            => WithElementAsync((h, o) => h.SelectTextAsync(ConvertOptions<ElementHandleSelectTextOptions>(o)), options);171        public Task SetInputFilesAsync(string files, LocatorSetInputFilesOptions options = null)172            => _frame.SetInputFilesAsync(_selector, files, ConvertOptions<FrameSetInputFilesOptions>(options));173        public Task SetInputFilesAsync(IEnumerable<string> files, LocatorSetInputFilesOptions options = null)174            => _frame.SetInputFilesAsync(_selector, files, ConvertOptions<FrameSetInputFilesOptions>(options));175        public Task SetInputFilesAsync(FilePayload files, LocatorSetInputFilesOptions options = null)176            => _frame.SetInputFilesAsync(_selector, files, ConvertOptions<FrameSetInputFilesOptions>(options));177        public Task SetInputFilesAsync(IEnumerable<FilePayload> files, LocatorSetInputFilesOptions options = null)178            => _frame.SetInputFilesAsync(_selector, files, ConvertOptions<FrameSetInputFilesOptions>(options));179        public Task TapAsync(LocatorTapOptions options = null)180            => _frame.TapAsync(_selector, ConvertOptions<FrameTapOptions>(options));181        public Task<string> TextContentAsync(LocatorTextContentOptions options = null)182            => _frame.TextContentAsync(_selector, ConvertOptions<FrameTextContentOptions>(options));183        public Task TypeAsync(string text, LocatorTypeOptions options = null)184            => _frame.TypeAsync(_selector, text, ConvertOptions<FrameTypeOptions>(options));185        public Task UncheckAsync(LocatorUncheckOptions options = null)186            => _frame.UncheckAsync(_selector, ConvertOptions<FrameUncheckOptions>(options));187        ILocator ILocator.Locator(string selector, LocatorLocatorOptions options)188            => new Locator(_frame, $"{_selector} >> {selector}", options);189        public Task WaitForAsync(LocatorWaitForOptions options = null)190            => _frame.LocatorWaitForAsync(_selector, ConvertOptions<LocatorWaitForOptions>(options));191        internal Task<FrameExpectResult> ExpectAsync(string expression, FrameExpectOptions options = null)192            => _frame.ExpectAsync(193                _selector,194                expression,195                options);196        public override string ToString() => "Locator@" + _selector;197        private T ConvertOptions<T>(object source)198            where T : class, new()199        {200            T target = new();201            var targetType = target.GetType();202            if (source != null)203            {204                var sourceType = source.GetType();205                foreach (var sourceProperty in sourceType.GetProperties())206                {207                    var targetProperty = targetType.GetProperty(sourceProperty.Name);208                    if (targetProperty != null)209                    {210                        targetProperty.SetValue(target, sourceProperty.GetValue(source));...

AssertionsBase.cs

Source:AssertionsBase.cs

...82            {83                throw new ArgumentNullException(nameof(pattern));84            }85            ExpectedTextValue textValue = options ?? new() { };86            textValue.RegexSource = pattern.ToString();87            textValue.RegexFlags = pattern.Options.GetInlineFlags();88            return textValue;89        }90        internal T ConvertToType<T>(object source)91            where T : new()92        {93            T target = new();94            if (source == null)95            {96                return target;97            }98            var sourceType = source.GetType();99            var targetType = target.GetType();100            foreach (var sourceProperty in sourceType.GetProperties())101            {102                var targetProperty = targetType.GetProperty(sourceProperty.Name);103                if (targetProperty != null)104                {105                    targetProperty.SetValue(target, sourceProperty.GetValue(source));106                }107            }108            return target;109        }110        internal FrameExpectOptions ConvertToFrameExpectOptions(object source) => ConvertToType<FrameExpectOptions>(source);111        private string FormatValue(object value)112        {113            if (value == null)114            {115                return "null";116            }117            if (value is string)118            {119                return (string)value;120            }121            if (value is IEnumerable<object>)122            {123                return "[" + string.Join(", ", ((IEnumerable<object>)value).Select(value => $"'{value}'")) + "]";124            }125            return value.ToString();126        }127    }128}...

ToString

Using AI Code Generation

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Microsoft.Playwright;7{8    {9        static async Task Main(string[] args)10        {11            using var playwright = await Playwright.CreateAsync();12            await using var browser = await playwright.Chromium.LaunchAsync(new LaunchOptions13            {14            });15            var page = await browser.NewPageAsync();16            var locator = page.Locator("input[name='q']");17            Console.WriteLine(locator.ToString());18            Console.ReadKey();19        }20    }21}

ToString

Using AI Code Generation

1using Microsoft.Playwright;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            using var playwright = await Playwright.CreateAsync();9            await using var browser = await playwright.Firefox.LaunchAsync(new BrowserTypeLaunchOptions10            {11            });12            var page = await browser.NewPageAsync();13            await page.ClickAsync("text=Sign in");14            await page.ClickAsync("xpath

ToString

Using AI Code Generation

1using Microsoft.Playwright;2using Microsoft.Playwright.Core;3using System;4using System.Collections.Generic;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8{9    {10        static async Task Main(string[] args)11        {12            using var playwright = await Playwright.CreateAsync();13            await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions14            {15            });16            var page = await browser.NewPageAsync();17            await page.ClickAsync("text=Sign in");18            await page.FillAsync("input[name=\"identifier\"]", "test");19            await page.PressAsync("input[name=\"identifier\"]", "Enter");20            await page.FillAsync("input[name=\"password\"]", "test");21            await page.PressAsync("input[name=\"password\"]", "Enter");22            await page.ScreenshotAsync(new PageScreenshotOptions23            {24            });25            await page.ClickAsync("text=Images");26            await page.ScreenshotAsync(new PageScreenshotOptions27            {28            });29            await page.ClickAsync("text=Sign out");30            await page.ScreenshotAsync(new PageScreenshotOptions31            {32            });33            await page.ClickAsync("text=Images");34            await page.ScreenshotAsync(new PageScreenshotOptions35            {36            });37            await page.ClickAsync("text=Sign in");38            await page.ScreenshotAsync(new PageScreenshotOptions39            {40            });41            await page.FillAsync("

ToString

Using AI Code Generation

1var playwright = await Microsoft.Playwright.Core.Playwright.CreateAsync();2var browser = await playwright.Chromium.LaunchAsync();3var page = await browser.NewPageAsync();4await page.ClickAsync("input[name=\"q\"]");5await page.TypeAsync("input[name=\"q\"]", "Playwright");6await page.ClickAsync("text=Google Search");7await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");8await page.ClickAsync("text=Get started");9await page.ClickAsync("text=API reference");10await page.ClickAsync("text=Playwright");11await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");12await page.ClickAsync("text=Get started");13await page.ClickAsync("text=API reference");14await page.ClickAsync("text=Playwright");15await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");16await page.ClickAsync("text=Get started");17await page.ClickAsync("text=API reference");18await page.ClickAsync("text=Playwright");19await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");20await page.ClickAsync("text=Get started");21await page.ClickAsync("text=API reference");22await page.ClickAsync("text=Playwright");23await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");24await page.ClickAsync("text=Get started");25await page.ClickAsync("text=API reference");26await page.ClickAsync("text=Playwright");27await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");28await page.ClickAsync("text=Get started");29await page.ClickAsync("text=API reference");30await page.ClickAsync("text=Playwright");31await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API");32await page.ClickAsync("text=Get started");33await page.ClickAsync("text=API reference");34await page.ClickAsync("text=Playwright");35await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit with a single API

ToString

Using AI Code Generation

1using Microsoft.Playwright;2using System;3using System.Threading.Tasks;4{5    static async Task Main()6    {7        using var playwright = await Playwright.CreateAsync();8        await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions9        {10        });11        var context = await browser.NewContextAsync();12        var page = await context.NewPageAsync();13        await page.ScreenshotAsync("example.png");14        var locator = page.Locator(".b_searchbox");15        Console.WriteLine(locator.ToString());16    }17}

ToString

Using AI Code Generation

1using System;2using Microsoft.Playwright;3using Microsoft.Playwright.Core;4{5    {6        static async Task Main(string[] args)7        {8            using var playwright = await Playwright.CreateAsync();9            using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions10            {11            });12            using var page = await browser.NewPageAsync();13            Locator locator = page.Locator("#tsf > div:nth-child(2) > div > div.FPdoLc.VlcLAe > center > input[type=\"submit\"]:nth-child(1)");14            Console.WriteLine(locator.ToString());15        }16    }17}18Locator: css=#tsf > div:nth-child(2) > div > div.FPdoLc.VlcLAe > center > input[type="submit"]:nth-child(1)19Method Description Locator.AtIndex(int index) Returns a new locator that matches the element at the specified index. Locator.AtMost(int count) Returns a new locator that matches at most the specified number of elements. Locator.AtMostOne() Returns a new locator that matches at most one element. Locator.AtMostOneOrNull() Returns a new locator that matches at most one element or null. Locator.AtMostOrNull(int count) Returns a new locator that matches at most the specified number of elements or null. Locator.AtMostOneOrNull() Returns a new locator that matches at most one element or null. Locator.AtMostOrNull(int count) Returns a new locator that matches at most the specified number of elements or null. Locator.First() Returns a new locator that matches the first element. Locator.FirstOrNull() Returns a new locator that matches the first element or null. Locator.Last() Returns a new locator that matches the last element. Locator.LastOrNull() Returns a new locator that matches the last element or null. Locator.WithText(string text) Returns a new locator that matches elements containing the specified text. Locator.WithText(Regex text) Returns a new locator that matches elements containing the specified text. Locator

ToString

Using AI Code Generation

1using Microsoft.Playwright;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            using var playwright = await Playwright.CreateAsync();9            var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions10            {11            });12            var page = await browser.NewPageAsync();13            await page.ClickAsync("text=About");14            await browser.CloseAsync();15        }16    }17}

Playwright tutorial

LambdaTest’s Playwright tutorial will give you a broader idea about the Playwright automation framework, its unique features, and use cases with examples to exceed your understanding of Playwright testing. This tutorial will give A to Z guidance, from installing the Playwright framework to some best practices and advanced concepts.

Chapters:

What is Playwright : Playwright is comparatively new but has gained good popularity. Get to know some history of the Playwright with some interesting facts connected with it.
How To Install Playwright : Learn in detail about what basic configuration and dependencies are required for installing Playwright and run a test. Get a step-by-step direction for installing the Playwright automation framework.
Playwright Futuristic Features: Launched in 2020, Playwright gained huge popularity quickly because of some obliging features such as Playwright Test Generator and Inspector, Playwright Reporter, Playwright auto-waiting mechanism and etc. Read up on those features to master Playwright testing.
What is Component Testing: Component testing in Playwright is a unique feature that allows a tester to test a single component of a web application without integrating them with other elements. Learn how to perform Component testing on the Playwright automation framework.
Inputs And Buttons In Playwright: Every website has Input boxes and buttons; learn about testing inputs and buttons with different scenarios and examples.
Functions and Selectors in Playwright: Learn how to launch the Chromium browser with Playwright. Also, gain a better understanding of some important functions like “BrowserContext,” which allows you to run multiple browser sessions, and “newPage” which interacts with a page.
Handling Alerts and Dropdowns in Playwright : Playwright interact with different types of alerts and pop-ups, such as simple, confirmation, and prompt, and different types of dropdowns, such as single selector and multi-selector get your hands-on with handling alerts and dropdown in Playright testing.
Playwright vs Puppeteer: Get to know about the difference between two testing frameworks and how they are different than one another, which browsers they support, and what features they provide.
Run Playwright Tests on LambdaTest: Playwright testing with LambdaTest leverages test performance to the utmost. You can run multiple Playwright tests in Parallel with the LammbdaTest test cloud. Get a step-by-step guide to run your Playwright test on the LambdaTest platform.
Playwright Python Tutorial: Playwright automation framework support all major languages such as Python, JavaScript, TypeScript, .NET and etc. However, there are various advantages to Python end-to-end testing with Playwright because of its versatile utility. Get the hang of Playwright python testing with this chapter.
Playwright End To End Testing Tutorial: Get your hands on with Playwright end-to-end testing and learn to use some exciting features such as TraceViewer, Debugging, Networking, Component testing, Visual testing, and many more.
Playwright Video Tutorial: Watch the video tutorials on Playwright testing from experts and get a consecutive in-depth explanation of Playwright automation testing.

Run Playwright-dotnet automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo

View Documentation Sign up Free

›

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

How to use ToString method of Microsoft.Playwright.Core.Locator class

Playwright tutorial

Chapters:

Run Playwright-dotnet automation tests on LambdaTest cloud grid

Most used method in Locator

Try LambdaTest Now !!

Was this article helpful?