How to use PageSetInputFilesOptions class of Microsoft.Playwright package

...1820        /// </param>1821        /// <param name="files">1822        /// </param>1823        /// <param name="options">Call options</param>1824        Task SetInputFilesAsync(string selector, string files, PageSetInputFilesOptions? options = default);1825        /// <summary>1826        /// <para>1827        /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input1828        /// element</a>.1829        /// </para>1830        /// <para>1831        /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>1832        /// are relative paths, then they are resolved relative to the the current working directory.1833        /// For empty array, clears the selected files.1834        /// </para>1835        /// </summary>1836        /// <param name="selector">1837        /// A selector to search for an element. If there are multiple elements satisfying the1838        /// selector, the first will be used. See <a href="https://playwright.dev/dotnet/docs/selectors">working1839        /// with selectors</a> for more details.1840        /// </param>1841        /// <param name="files">1842        /// </param>1843        /// <param name="options">Call options</param>1844        Task SetInputFilesAsync(string selector, IEnumerable<string> files, PageSetInputFilesOptions? options = default);1845        /// <summary>1846        /// <para>1847        /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input1848        /// element</a>.1849        /// </para>1850        /// <para>1851        /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>1852        /// are relative paths, then they are resolved relative to the the current working directory.1853        /// For empty array, clears the selected files.1854        /// </para>1855        /// </summary>1856        /// <param name="selector">1857        /// A selector to search for an element. If there are multiple elements satisfying the1858        /// selector, the first will be used. See <a href="https://playwright.dev/dotnet/docs/selectors">working1859        /// with selectors</a> for more details.1860        /// </param>1861        /// <param name="files">1862        /// </param>1863        /// <param name="options">Call options</param>1864        Task SetInputFilesAsync(string selector, FilePayload files, PageSetInputFilesOptions? options = default);1865        /// <summary>1866        /// <para>1867        /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input1868        /// element</a>.1869        /// </para>1870        /// <para>1871        /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>1872        /// are relative paths, then they are resolved relative to the the current working directory.1873        /// For empty array, clears the selected files.1874        /// </para>1875        /// </summary>1876        /// <param name="selector">1877        /// A selector to search for an element. If there are multiple elements satisfying the1878        /// selector, the first will be used. See <a href="https://playwright.dev/dotnet/docs/selectors">working1879        /// with selectors</a> for more details.1880        /// </param>1881        /// <param name="files">1882        /// </param>1883        /// <param name="options">Call options</param>1884        Task SetInputFilesAsync(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions? options = default);1885        /// <summary>1886        /// <para>1887        /// In the case of multiple pages in a single browser, each page can have its own viewport1888        /// size. However, <see cref="IBrowser.NewContextAsync"/> allows to set viewport size1889        /// (and more) for all pages in the context at once.1890        /// </para>1891        /// <para>1892        /// <see cref="IPage.SetViewportSizeAsync"/> will resize the page. A lot of websites1893        /// don't expect phones to change size, so you should set the viewport size before navigating1894        /// to the page. <see cref="IPage.SetViewportSizeAsync"/> will also reset <c>screen</c>1895        /// size, use <see cref="IBrowser.NewContextAsync"/> with <c>screen</c> and <c>viewport</c>1896        /// parameters if you need better control of these properties.1897        /// </para>1898        /// <code>...

...914    /// </param>915    /// <param name="files">916    /// </param>917    /// <param name="options">Call options</param>918    public static IPage SetInputFiles(this IPage page, string selector, string files, PageSetInputFilesOptions? options = null)919    {920        page.SetInputFilesAsync(selector, files, options).GetAwaiter().GetResult();921        return page;922    }923    /// <summary>924    /// <para>925    /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input926    /// element</a>.927    /// </para>928    /// <para>929    /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>930    /// are relative paths, then they are resolved relative to the the current working directory.931    /// For empty array, clears the selected files.932    /// </para>933    /// </summary>934    /// <param name="selector">935    /// A selector to search for an element. If there are multiple elements satisfying the936    /// selector, the first will be used. See <a href="./selectors.md">working with selectors</a>937    /// for more details.938    /// </param>939    /// <param name="files">940    /// </param>941    /// <param name="options">Call options</param>942    public static IPage SetInputFiles(this IPage page, string selector, FilePayload files, PageSetInputFilesOptions? options = null)943    {944        page.SetInputFilesAsync(selector, files, options).GetAwaiter().GetResult();945        return page;946    }947    /// <summary>948    /// <para>949    /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input950    /// element</a>.951    /// </para>952    /// <para>953    /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>954    /// are relative paths, then they are resolved relative to the the current working directory.955    /// For empty array, clears the selected files.956    /// </para>957    /// </summary>958    /// <param name="selector">959    /// A selector to search for an element. If there are multiple elements satisfying the960    /// selector, the first will be used. See <a href="./selectors.md">working with selectors</a>961    /// for more details.962    /// </param>963    /// <param name="files">964    /// </param>965    /// <param name="options">Call options</param>966    public static IPage SetInputFiles(this IPage page, string selector, IEnumerable<string> files, PageSetInputFilesOptions? options = null)967    {968        page.SetInputFilesAsync(selector, files, options).GetAwaiter().GetResult();969        return page;970    }971    /// <summary>972    /// <para>973    /// This method expects <paramref name="selector"/> to point to an <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input">input974    /// element</a>.975    /// </para>976    /// <para>977    /// Sets the value of the file input to these file paths or files. If some of the <c>filePaths</c>978    /// are relative paths, then they are resolved relative to the the current working directory.979    /// For empty array, clears the selected files.980    /// </para>981    /// </summary>982    /// <param name="selector">983    /// A selector to search for an element. If there are multiple elements satisfying the984    /// selector, the first will be used. See <a href="./selectors.md">working with selectors</a>985    /// for more details.986    /// </param>987    /// <param name="files">988    /// </param>989    /// <param name="options">Call options</param>990    public static IPage SetInputFiles(this IPage page, string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions? options = null)991    {992        page.SetInputFilesAsync(selector, files, options).GetAwaiter().GetResult();993        return page;994    }995    /// <summary><para>Returns <c>element.innerHTML</c>.</para></summary>996    /// <param name="selector">997    /// A selector to search for an element. If there are multiple elements satisfying the998    /// selector, the first will be used. See <a href="./selectors.md">working with selectors</a>999    /// for more details.1000    /// </param>1001    /// <param name="options">Call options</param>1002    public static string InnerHTML(this IPage page, string selector, PageInnerHTMLOptions? options = null)1003    {1004        return page.InnerHTMLAsync(selector, options).GetAwaiter().GetResult();...

...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);801            Close?.Invoke(this, this);802        }803        private void Channel_Crashed(object sender, EventArgs e)804        {805            RejectPendingOperations(true);806            Crash?.Invoke(this, this);807        }808        private void Channel_BindingCall(object sender, BindingCallEventArgs e)809        {810            if (Bindings.TryGetValue(e.BindingCall.Name, out var binding))811            {812                _ = e.BindingCall.CallAsync(binding);813            }814        }815        private void OnRoute(Route route, IRequest request)816        {817            foreach (var routeHandler in _routes.ToList())818            {819                if ((routeHandler.Regex?.IsMatch(request.Url) == true) ||820                    (routeHandler.Function?.Invoke(request.Url) == true))821                {822                    try823                    {824                        routeHandler.Handle(route);825                    }826                    finally827                    {828                        if (!routeHandler.IsActive())829                        {830                            _routes.Remove(routeHandler);831                            if (_routes.Count == 0)832                            {833                                DisableInterceptionAsync().ConfigureAwait(false);834                            }835                        }836                    }837                    return;838                }839            }840            Context.OnRoute(route, request);841        }842        internal async Task DisableInterceptionAsync()843        {844            await Channel.SetNetworkInterceptionEnabledAsync(false).ConfigureAwait(false);845        }846        private void Channel_FrameDetached(object sender, IFrame args)847        {848            var frame = (Frame)args;849            _frames.Remove(frame);850            frame.IsDetached = true;851            frame.ParentFrame?.ChildFramesList?.Remove(frame);852            FrameDetached?.Invoke(this, args);853        }854        private void Channel_FrameAttached(object sender, IFrame args)855        {856            var frame = (Frame)args;857            frame.Page = this;858            _frames.Add(frame);859            frame.ParentFrame?.ChildFramesList?.Add(frame);860            FrameAttached?.Invoke(this, args);861        }862        private void RejectPendingOperations(bool isCrash)863        {864            foreach (var (_, waitTcs) in _waitForCancellationTcs.Where(e => e.PageEvent != (isCrash ? PageEvent.Crash : PageEvent.Close)))865            {866                waitTcs.TrySetException(new PlaywrightException(isCrash ? "Page crashed" : "Page closed"));867            }868            _waitForCancellationTcs.Clear();869        }870        private Task InnerExposeBindingAsync(string name, Delegate callback, bool handle = false)871        {872            if (Bindings.ContainsKey(name))873            {874                throw new PlaywrightException($"Function \"{name}\" has been already registered");875            }876            Bindings.Add(name, callback);877            return _channel.ExposeBindingAsync(name, handle);878        }879        private Video ForceVideo() => _video ??= new(this, _channel.Connection);880        private FrameSetInputFilesOptions Map(PageSetInputFilesOptions options)881        {882            if (options == null)883            {884                return null;885            }886            return new()887            {888                NoWaitAfter = options.NoWaitAfter,889                Timeout = options.Timeout,890                Strict = options.Strict,891            };892        }893    }894}...

...237    {238        var result = this.Page.SelectOption(selector, values, options);239        return result;240    }241    protected virtual void SetInputFiles(string selector, string files, PageSetInputFilesOptions? options = null)242    {243        this.Page.SetInputFiles(selector, files, options);244    }245    protected virtual void SetInputFiles(string selector, FilePayload files, PageSetInputFilesOptions? options = null)246    {247        this.Page.SetInputFiles(selector, files, options);248    }249    protected virtual void SetInputFiles(string selector, IEnumerable<string> files, PageSetInputFilesOptions? options = null)250    {251        this.Page.SetInputFiles(selector, files, options);252    }253    protected virtual void SetInputFiles(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions? options = null)254    {255        this.Page.SetInputFiles(selector, files, options);256    }257    protected virtual void AddInitScript(string? script = null, string? scriptPath = null)258    {259        this.Page.AddInitScript(script, scriptPath);260    }261    protected virtual void AddScriptTag(PageAddScriptTagOptions? options = null)262    {263        this.Page.AddScriptTag(options);264    }265    protected virtual void AddStyleTag(PageAddStyleTagOptions? options = null)266    {267        this.Page.AddStyleTag(options);...

...97        public void SetExtraHTTPHeaders(IEnumerable<KeyValuePair<string, string>> headers)98        {99            this.AsyncPage.SetExtraHTTPHeadersAsync(headers).Wait();100        }101        /// <inheritdoc cref = "IPage.SetInputFilesAsync(string, FilePayload, PageSetInputFilesOptions)" /> 102        public void SetInputFiles(string selector, FilePayload files, PageSetInputFilesOptions? options = null)103        {104            this.AsyncPage.SetInputFilesAsync(selector, files, options).Wait();105        }106        /// <inheritdoc cref = "IPage.SetInputFilesAsync(string, IEnumerable{FilePayload}, PageSetInputFilesOptions)" /> 107        public void SetInputFiles(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions? options = null)108        {109            this.AsyncPage.SetInputFilesAsync(selector, files, options).Wait();110        }111        /// <inheritdoc cref = "IPage.SetInputFilesAsync(string, IEnumerable{string}, PageSetInputFilesOptions)" /> 112        public void SetInputFiles(string selector, IEnumerable<string> files, PageSetInputFilesOptions? options = null)113        {114            this.AsyncPage.SetInputFilesAsync(selector, files, options).Wait();115        }116        /// <inheritdoc cref = "IPage.SetInputFilesAsync(string, string, PageSetInputFilesOptions)" /> 117        public void SetInputFiles(string selector, string files, PageSetInputFilesOptions? options = null)118        {119            this.AsyncPage.SetInputFilesAsync(selector, files, options).Wait();120        }121        /// <inheritdoc cref = "IPage.SetViewportSizeAsync" /> 122        public void SetViewportSize(int width, int height)123        {124            this.AsyncPage.SetViewportSizeAsync(width, height).Wait();125        }126        /// <inheritdoc cref = "IPage.TapAsync" /> 127        public void Tap(string selector, PageTapOptions? options = null)128        {129            this.AsyncPage.TapAsync(selector, options).Wait();130        }131        /// <inheritdoc cref = "IPage.TypeAsync" /> ...

...35using System.Threading.Tasks;36#nullable enable37namespace Microsoft.Playwright38{39    public class PageSetInputFilesOptions40    {41        public PageSetInputFilesOptions() { }42        public PageSetInputFilesOptions(PageSetInputFilesOptions clone)43        {44            if (clone == null)45            {46                return;47            }48            NoWaitAfter = clone.NoWaitAfter;49            Strict = clone.Strict;50            Timeout = clone.Timeout;51        }52        /// <summary>53        /// <para>54        /// Actions that initiate navigations are waiting for these navigations to happen and55        /// for pages to start loading. You can opt out of waiting via setting this flag. You56        /// would only need this option in the exceptional cases such as navigating to inaccessible...

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 BrowserTypeLaunchOptions13            {14            });15            var context = await browser.NewContextAsync(new BrowserNewContextOptions16            {17            });18            var page = await context.NewPageAsync();19            await page.SetInputFilesAsync("input[type=file]", new[] { "C:\\Users\\rohit\\Desktop\\test.png" });20            await page.ClickAsync("text=Upload");21        }22    }23}24using System;25using System.Collections.Generic;26using System.Linq;27using System.Text;28using System.Threading.Tasks;29using Microsoft.Playwright;30{31    {32        static async Task Main(string[] args)33        {34            using var playwright = await Playwright.CreateAsync();35            await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions36            {37            });38            var context = await browser.NewContextAsync(new BrowserNewContextOptions39            {40            });41            var page = await context.NewPageAsync();

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 LaunchOptions10            {11            });12            var context = await browser.NewContextAsync(new BrowserNewContextOptions13            {14            });15            var page = await context.NewPageAsync();16            await page.TypeAsync("input[title='Search']", "Playwright");17            await page.ClickAsync("input[value='Google Search']");18            await page.WaitForSelectorAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit");19            await page.ClickAsync("text=Playwright: Node.js library to automate Chromium, Firefox and WebKit");20            await page.WaitForSelectorAsync("text=Playwright is a Node library to automate Chromium, Firefox and WebKit with a single API.");21            await page.ClickAsync("text=Get Started");22            await page.WaitForSelectorAsync("text=Quick Start");23            await page.ClickAsync("text=Quick Start");24            await page.WaitForSelectorAsync("text=Create a test file");25            await page.ClickAsync("text=Create a test file");26            await page.WaitForSelectorAsync("text=My first test");27            await page.ClickAsync("text=My first test");28            await page.WaitForSelectorAsync("text=Run your first test");29            await page.ClickAsync("text=Run your first test");30            await page.WaitForSelectorAsync("text=Install Playwright");31            await page.ClickAsync("text=Install Playwright");32            await page.WaitForSelectorAsync("text=Playwright is a Node library to automate Chromium, Firefox and WebKit with a single API.");33            await page.ClickAsync("text=Get Started");34            await page.WaitForSelectorAsync("text=Quick Start");35            await page.ClickAsync("text=Quick Start");36            await page.WaitForSelectorAsync("text=Create a test file");37            await page.ClickAsync("text=Create a test file");38            await page.WaitForSelectorAsync("text=My first test");39            await page.ClickAsync("text=My first test");40            await page.WaitForSelectorAsync("text=Run your first test");41            await page.ClickAsync("text=Run

1using Microsoft.Playwright;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            await using var playwright = await Playwright.CreateAsync();9            await using var browser = await playwright.Chromium.LaunchAsync();10            var page = await browser.NewPageAsync();11            var options = new PageSetInputFilesOptions();12            options.Files = new FilePayload[] { new FilePayload() { Name = "test.txt", MimeType = "text/plain", Buffer = System.Text.Encoding.UTF8.GetBytes("Hello world") } };13            await page.SetInputFilesAsync("input[type=file]", options);14        }15    }16}17using Microsoft.Playwright;18using System;19using System.Threading.Tasks;20{21    {22        static async Task Main(string[] args)23        {24            await using var playwright = await Playwright.CreateAsync();25            await using var browser = await playwright.Chromium.LaunchAsync();26            var page = await browser.NewPageAsync();27            var options = new PageSetInputFilesOptions();28            options.Files = new FilePayload[] { new FilePayload() { Name = "test.txt", MimeType = "text/plain", Buffer = System.Text.Encoding.UTF8.GetBytes("Hello world") } };29            await page.SetInputFilesAsync("input[type=file]", options);30        }31    }32}33using Microsoft.Playwright;34using System;35using System.Threading.Tasks;36{37    {38        static async Task Main(string[] args)39        {40            await using var playwright = await Playwright.CreateAsync();41            await using var browser = await playwright.Chromium.LaunchAsync();42            var page = await browser.NewPageAsync();43            var options = new PageSetInputFilesOptions();44            options.Files = new FilePayload[] { new FilePayload() { Name = "test.txt", MimeType = "text/plain", Buffer = System.Text.Encoding.UTF8.GetBytes("Hello world") } };45            await page.SetInputFilesAsync("input[type=file]", options);46        }47    }48}

1using System;2using System.Collections.Generic;3using System.Threading.Tasks;4using Microsoft.Playwright;5{6    {7        static async Task Main(string[] args)8        {9            using var playwright = await Playwright.CreateAsync();10            await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions11            {12            });13            var context = await browser.NewContextAsync();14            var page = await context.NewPageAsync();15            await page.SwitchToFrameAsync("iframeResult");16            await page.SetInputFilesAsync("input[type='file']", new[] { "C:\\Users\\Public\\Pictures\\Sample Pictures\\Desert.jpg" });17            Console.Read();18        }19    }20}21using System;22using System.Collections.Generic;23using System.Threading.Tasks;24using Microsoft.Playwright;25{26    {27        static async Task Main(string[] args)28        {29            using var playwright = await Playwright.CreateAsync();30            await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions31            {32            });33            var context = await browser.NewContextAsync();34            var page = await context.NewPageAsync();35            await page.SwitchToFrameAsync("iframeResult");36            await page.SetInputFilesAsync("input[type='file']", new[] { "C:\\Users\\Public\\Pictures\\Sample Pictures\\Desert.jpg" }, new PageSetInputFilesOptions37            {38            });39            Console.Read();40        }41    }42}43using System;44using System.Collections.Generic;45using System.Threading.Tasks;46using Microsoft.Playwright;47{48    {49        static async Task Main(string[] args)50        {

1var playwright = require("playwright");2var fs = require("fs");3(async () => {4  for (const browserType of BROWSER) {5    const browser = await playwright[browserType].launch();6    const context = await browser.newContext();7    const page = await context.newPage();8    await page.waitForTimeout(5000);9    await page.click("[aria-label='Run']");10    await page.waitForTimeout(10000);11    await page.click("[aria-label='Close']");12    await page.waitForTimeout(5000);13    await page.click("#iframeResult");14    await page.waitForTimeout(5000);15    const input = await page.$("input[type=file]");16    await input.setInputFiles("C:\\Users\\admin\\Desktop\\resume.docx");17    await page.waitForTimeout(5000);18    await browser.close();19  }20})();21var playwright = require("playwright");22var fs = require("fs");23(async () => {24  for (const browserType of BROWSER) {25    const browser = await playwright[browserType].launch();26    const context = await browser.newContext();27    const page = await context.newPage();28    await page.waitForTimeout(5000);29    await page.click("[aria-label='Run']");30    await page.waitForTimeout(10000);31    await page.click("[aria-label='Close']");32    await page.waitForTimeout(5000);33    await page.click("#iframeResult");34    await page.waitForTimeout(5000);35    const input = await page.$("input[type=file]");36    await input.setInputFiles("C:\\Users\\admin\\Desktop\\resume.docx", { timeout: 30000 });37    await page.waitForTimeout(5000);38    await browser.close();39  }40})();

1using System;2using System.Threading.Tasks;3using Microsoft.Playwright;4{5    {6        static async Task Main(string[] args)7        {8            using var playwright = await Playwright.CreateAsync();9            await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions10            {11            });12            var context = await browser.NewContextAsync();13            var page = await context.NewPageAsync();14            await page.SetInputFilesAsync("input[type=file]", "C:\\Users\\MyUser\\Desktop\\HelloWorld.txt");15        }16    }17}

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.Chromium.LaunchAsync(new BrowserTypeLaunchOptions10            {11            });12            var context = await browser.NewContextAsync(new BrowserNewContextOptions13            {14                {15                }16            });17            var page = await context.NewPageAsync();18            await page.ClickAsync("text=Try it");19            await page.SwitchToIframeAsync("iframeResult");20            await page.SetInputFilesAsync("input[type='file']", new string[] { "C:\\Users\\Public\\Pictures\\Sample Pictures\\Tulips.jpg" }, new PageSetInputFilesOptions { Timeout = 1000 });21            await Task.Delay(3000);22            await page.ScreenshotAsync("C:\\Users\\Public\\Pictures\\Sample Pictures\\Tulips.jpg");23        }24    }25}

1using System;2using System.Threading.Tasks;3using Microsoft.Playwright;4{5    {6        static async Task Main(string[] args)7        {8            using var playwright = await Playwright.CreateAsync();9            await using var browser = await playwright.Chromium.LaunchAsync(new()10            {11            });12            var context = await browser.NewContextAsync();13            var page = await context.NewPageAsync();14            var files = new string[] { "C:\\Users\\user\\Desktop\\2.txt" };15            await page.SetInputFilesAsync("input[type=file]", files);16        }17    }18}19using System;20using System.Threading.Tasks;21using Microsoft.Playwright;22{23    {24        static async Task Main(string[] args)25        {26            using var playwright = await Playwright.CreateAsync();27            await using var browser = await playwright.Chromium.LaunchAsync(new()28            {29            });30            var context = await browser.NewContextAsync();31            var page = await context.NewPageAsync();32            var files = new string[] { "C:\\Users\\user\\Desktop\\2.txt" };33            await page.SetInputFilesAsync("input[type=file]", files);34        }35    }36}37using System;38using System.Threading.Tasks;39using Microsoft.Playwright;40{41    {42        static async Task Main(string[] args)43        {44            using var playwright = await Playwright.CreateAsync();

1using Microsoft.Playwright;2{3    {4        static async Task Main(string[] args)5        {6            using var playwright = await Playwright.CreateAsync();7            await using var browser = await playwright.Chromium.LaunchAsync(new LaunchOptions8            {9            });10            var context = await browser.NewContextAsync();11            var page = await context.NewPageAsync();12            await page.SwitchToFrameAsync("iframeResult");13            await page.SetInputFilesAsync("input[type=file]", new PageSetInputFilesOptions14            {15                Files = new string[] { @"C:\Users\Public\Pictures\Sample Pictures\Koala.jpg" }16            });17            Console.ReadLine();18        }19    }20}