How to use ExitedState class of PuppeteerSharp.States package

...292            private static readonly StartingState Starting = new StartingState();293            private static readonly StartedState Started = new StartedState();294            private static readonly ExitingState Exiting = new ExitingState();295            private static readonly KillingState Killing = new KillingState();296            private static readonly ExitedState Exited = new ExitedState();297            private static readonly DisposedState Disposed = new DisposedState();298            #endregion299            #region Properties300            public bool IsExiting => this == Killing || this == Exiting;301            public bool IsExited => this == Exited || this == Disposed;302            #endregion303            #region Methods304            /// <summary>305            /// Attempts thread-safe transitions from a given state to this state.306            /// </summary>307            /// <param name="p">The Chromium process</param>308            /// <param name="fromState">The state from which state transition takes place</param>309            /// <returns>Returns <c>true</c> if transition is successful, or <c>false</c> if transition310            /// cannot be made because current state does not equal <paramref name="fromState"/>.</returns>311            protected bool TryEnter(ChromiumProcess p, State fromState)312            {313                if (Interlocked.CompareExchange(ref p._currentState, this, fromState) == fromState)314                {315                    fromState.Leave(p);316                    return true;317                }318                return false;319            }320            /// <summary>321            /// Notifies that state machine is about to transition to another state.322            /// </summary>323            /// <param name="p">The Chromium process</param>324            protected virtual void Leave(ChromiumProcess p)325            { }326            /// <summary>327            /// Handles process start request.328            /// </summary>329            /// <param name="p">The Chromium process</param>330            /// <returns></returns>331            public virtual Task StartAsync(ChromiumProcess p) => Task.FromException(InvalidOperation("start"));332            /// <summary>333            /// Handles process exit request.334            /// </summary>335            /// <param name="p">The Chromium process</param>336            /// <param name="timeout">The maximum waiting time for a graceful process exit.</param>337            /// <returns></returns>338            public virtual Task ExitAsync(ChromiumProcess p, TimeSpan timeout) => Task.FromException(InvalidOperation("exit"));339            /// <summary>340            /// Handles process kill request.341            /// </summary>342            /// <param name="p">The Chromium process</param>343            /// <returns></returns>344            public virtual Task KillAsync(ChromiumProcess p) => Task.FromException(InvalidOperation("kill"));345            /// <summary>346            /// Handles wait for process exit request.347            /// </summary>348            /// <param name="p">The Chromium process</param>349            /// <returns></returns>350            public virtual Task WaitForExitAsync(ChromiumProcess p) => p._exitCompletionSource.Task;351            /// <summary>352            /// Handles disposal of process and temporary user directory353            /// </summary>354            /// <param name="p"></param>355            public virtual void Dispose(ChromiumProcess p) => Disposed.EnterFrom(p, this);356            public override string ToString()357            {358                var name = GetType().Name;359                return name.Substring(0, name.Length - "State".Length);360            }361            private Exception InvalidOperation(string operationName)362                => new InvalidOperationException($"Cannot {operationName} in state {this}");363            /// <summary>364            /// Kills process if it is still alive.365            /// </summary>366            /// <param name="p"></param>367            private static void Kill(ChromiumProcess p)368            {369                try370                {371                    if (!p.Process.HasExited)372                    {373                        p.Process.Kill();374                    }375                }376                catch (InvalidOperationException)377                {378                    // Ignore379                }380            }381            #endregion382            #region Concrete state classes383            private class InitialState : State384            {385                public override Task StartAsync(ChromiumProcess p) => Starting.EnterFromAsync(p, this);386                public override Task ExitAsync(ChromiumProcess p, TimeSpan timeout)387                {388                    Exited.EnterFrom(p, this);389                    return Task.CompletedTask;390                }391                public override Task KillAsync(ChromiumProcess p)392                {393                    Exited.EnterFrom(p, this);394                    return Task.CompletedTask;395                }396                public override Task WaitForExitAsync(ChromiumProcess p) => Task.FromException(InvalidOperation("wait for exit"));397            }398            private class StartingState : State399            {400                public Task EnterFromAsync(ChromiumProcess p, State fromState)401                {402                    if (!TryEnter(p, fromState))403                    {404                        // Delegate StartAsync to current state, because it has already changed since405                        // transition to this state was initiated.406                        return p._currentState.StartAsync(p);407                    }408                    return StartCoreAsync(p);409                }410                public override Task StartAsync(ChromiumProcess p) => p._startCompletionSource.Task;411                public override Task ExitAsync(ChromiumProcess p, TimeSpan timeout) => Exiting.EnterFromAsync(p, this, timeout);412                public override Task KillAsync(ChromiumProcess p) => Killing.EnterFromAsync(p, this);413                public override void Dispose(ChromiumProcess p)414                {415                    p._startCompletionSource.TrySetException(new ObjectDisposedException(p.ToString()));416                    base.Dispose(p);417                }418                private async Task StartCoreAsync(ChromiumProcess p)419                {420                    var output = new StringBuilder();421                    void OnProcessDataReceivedWhileStarting(object sender, DataReceivedEventArgs e)422                    {423                        if (e.Data != null)424                        {425                            output.AppendLine(e.Data);426                            var match = Regex.Match(e.Data, "^DevTools listening on (ws:\\/\\/.*)");427                            if (match.Success)428                            {429                                p._startCompletionSource.SetResult(match.Groups[1].Value);430                            }431                        }432                    }433                    void OnProcessExitedWhileStarting(object sender, EventArgs e)434                    {435                        p._startCompletionSource.SetException(new ChromiumProcessException($"Failed to launch Chromium! {output}"));436                    }437                    void OnProcessExited(object sender, EventArgs e)438                    {439                        Exited.EnterFrom(p, p._currentState);440                    }441                    p.Process.ErrorDataReceived += OnProcessDataReceivedWhileStarting;442                    p.Process.Exited += OnProcessExitedWhileStarting;443                    p.Process.Exited += OnProcessExited;444                    CancellationTokenSource cts = null;445                    try446                    {447                        p.Process.Start();448                        await Started.EnterFromAsync(p, this).ConfigureAwait(false);449                        p.Process.BeginErrorReadLine();450                        var timeout = p._options.Timeout;451                        if (timeout > 0)452                        {453                            cts = new CancellationTokenSource(timeout);454                            cts.Token.Register(() => p._startCompletionSource.TrySetException(455                                new ChromiumProcessException($"Timed out after {timeout} ms while trying to connect to Chromium!")));456                        }457                        try458                        {459                            await p._startCompletionSource.Task.ConfigureAwait(false);460                            await Started.EnterFromAsync(p, this).ConfigureAwait(false);461                        }462                        catch463                        {464                            await Killing.EnterFromAsync(p, this).ConfigureAwait(false);465                            throw;466                        }467                    }468                    finally469                    {470                        cts?.Dispose();471                        p.Process.Exited -= OnProcessExitedWhileStarting;472                        p.Process.ErrorDataReceived -= OnProcessDataReceivedWhileStarting;473                    }474                }475            }476            private class StartedState : State477            {478                public Task EnterFromAsync(ChromiumProcess p, State fromState)479                {480                    if (TryEnter(p, fromState))481                    {482                        // Process has not exited or been killed since transition to this state was initiated483                        LogProcessCount(p, Interlocked.Increment(ref _processCount));484                    }485                    return Task.CompletedTask;486                }487                protected override void Leave(ChromiumProcess p)488                    => LogProcessCount(p, Interlocked.Decrement(ref _processCount));489                public override Task StartAsync(ChromiumProcess p) => Task.CompletedTask;490                public override Task ExitAsync(ChromiumProcess p, TimeSpan timeout) => Exiting.EnterFromAsync(p, this, timeout);491                public override Task KillAsync(ChromiumProcess p) => Killing.EnterFromAsync(p, this);492                private static void LogProcessCount(ChromiumProcess p, int processCount)493                {494                    try495                    {496                        p._logger?.LogInformation("Process Count: {ProcessCount}", processCount);497                    }498                    catch499                    {500                        // Prevent logging exception from causing havoc501                    }502                }503            }504            private class ExitingState : State505            {506                public Task EnterFromAsync(ChromiumProcess p, State fromState, TimeSpan timeout)507                {508                    return !TryEnter(p, fromState) ? p._currentState.ExitAsync(p, timeout) : ExitAsync(p, timeout);509                }510                public override async Task ExitAsync(ChromiumProcess p, TimeSpan timeout)511                {512                    var timeoutTask = Task.Delay(timeout);513                    var waitForExitTask = WaitForExitAsync(p);514                    var completedTask = await Task.WhenAny(waitForExitTask, timeoutTask).ConfigureAwait(false);515                    if (completedTask == timeoutTask)516                    {517                        await Killing.EnterFromAsync(p, this).ConfigureAwait(false);518                        await waitForExitTask.ConfigureAwait(false);519                    }520                }521                public override Task KillAsync(ChromiumProcess p) => Killing.EnterFromAsync(p, this);522            }523            private class KillingState : State524            {525                public Task EnterFromAsync(ChromiumProcess p, State fromState)526                {527                    if (!TryEnter(p, fromState))528                    {529                        // Delegate KillAsync to current state, because it has already changed since530                        // transition to this state was initiated.531                        return p._currentState.KillAsync(p);532                    }533                    try534                    {535                        if (!p.Process.HasExited)536                        {537                            p.Process.Kill();538                        }539                    }540                    catch (InvalidOperationException)541                    {542                        // Ignore543                    }544                    return WaitForExitAsync(p);545                }546                public override Task ExitAsync(ChromiumProcess p, TimeSpan timeout) => WaitForExitAsync(p);547                public override Task KillAsync(ChromiumProcess p) => WaitForExitAsync(p);548            }549            private class ExitedState : State550            {551                public void EnterFrom(ChromiumProcess p, State fromState)552                {553                    while (!TryEnter(p, fromState))554                    {555                        // Current state has changed since transition to this state was requested.556                        // Therefore retry transition to this state from the current state. This ensures557                        // that Leave() operation of current state is properly called.558                        fromState = p._currentState;559                        if (fromState == this)560                        {561                            return;562                        }563                    }...

...214            private static readonly StartingState Starting = new StartingState();215            private static readonly StartedState Started = new StartedState();216            private static readonly ExitingState Exiting = new ExitingState();217            private static readonly KillingState Killing = new KillingState();218            private static readonly ExitedState Exited = new ExitedState();219            private static readonly DisposedState Disposed = new DisposedState();220            #endregion221            #region Properties222            /// <summary>223            /// Get If process exists.224            /// </summary>225            public bool IsExiting => this == Killing || this == Exiting;226            /// <summary>227            /// Get If process is exited.228            /// </summary>229            public bool IsExited => this == Exited || this == Disposed;230            #endregion231            #region Methods232            /// <summary>233            /// Attempts thread-safe transitions from a given state to this state.234            /// </summary>235            /// <param name="p">The Base process</param>236            /// <param name="fromState">The state from which state transition takes place</param>237            /// <returns>Returns <c>true</c> if transition is successful, or <c>false</c> if transition238            /// cannot be made because current state does not equal <paramref name="fromState"/>.</returns>239            protected bool TryEnter(LauncherBase p, State fromState)240            {241                if (Interlocked.CompareExchange(ref p._currentState, this, fromState) == fromState)242                {243                    fromState.Leave(p);244                    return true;245                }246                return false;247            }248            /// <summary>249            /// Notifies that state machine is about to transition to another state.250            /// </summary>251            /// <param name="p">The Base process</param>252            protected virtual void Leave(LauncherBase p)253            {254            }255            /// <summary>256            /// Handles process start request.257            /// </summary>258            /// <param name="p">The Base process</param>259            /// <returns></returns>260            public virtual Task StartAsync(LauncherBase p) => Task.FromException(InvalidOperation("start"));261            /// <summary>262            /// Handles process exit request.263            /// </summary>264            /// <param name="p">The Base process</param>265            /// <param name="timeout">The maximum waiting time for a graceful process exit.</param>266            /// <returns></returns>267            public virtual Task ExitAsync(LauncherBase p, TimeSpan timeout) => Task.FromException(InvalidOperation("exit"));268            /// <summary>269            /// Handles process kill request.270            /// </summary>271            /// <param name="p">The Base process</param>272            /// <returns></returns>273            public virtual Task KillAsync(LauncherBase p) => Task.FromException(InvalidOperation("kill"));274            /// <summary>275            /// Handles wait for process exit request.276            /// </summary>277            /// <param name="p">The Base process</param>278            /// <returns></returns>279            public virtual Task WaitForExitAsync(LauncherBase p) => p._exitCompletionSource.Task;280            /// <summary>281            /// Handles disposal of process and temporary user directory282            /// </summary>283            /// <param name="p"></param>284            public virtual void Dispose(LauncherBase p) => Disposed.EnterFrom(p, this);285            /// <inheritdoc />286            public override string ToString()287            {288                string name = GetType().Name;289                return name.Substring(0, name.Length - "State".Length);290            }291            private Exception InvalidOperation(string operationName)292                => new InvalidOperationException($"Cannot {operationName} in state {this}");293            /// <summary>294            /// Kills process if it is still alive.295            /// </summary>296            /// <param name="p"></param>297            private static void Kill(LauncherBase p)298            {299                try300                {301                    if (!p.Process.HasExited)302                    {303                        p.Process.Kill();304                    }305                }306                catch (InvalidOperationException)307                {308                    // Ignore309                }310            }311            #endregion312            #region Concrete state classes313            private class InitialState : State314            {315                public override Task StartAsync(LauncherBase p) => Starting.EnterFromAsync(p, this);316                public override Task ExitAsync(LauncherBase p, TimeSpan timeout)317                {318                    Exited.EnterFrom(p, this);319                    return Task.CompletedTask;320                }321                public override Task KillAsync(LauncherBase p)322                {323                    Exited.EnterFrom(p, this);324                    return Task.CompletedTask;325                }326                public override Task WaitForExitAsync(LauncherBase p) => Task.FromException(InvalidOperation("wait for exit"));327            }328            private class StartingState : State329            {330                public Task EnterFromAsync(LauncherBase p, State fromState)331                {332                    if (!TryEnter(p, fromState))333                    {334                        // Delegate StartAsync to current state, because it has already changed since335                        // transition to this state was initiated.336                        return p._currentState.StartAsync(p);337                    }338                    return StartCoreAsync(p);339                }340                public override Task StartAsync(LauncherBase p) => p._startCompletionSource.Task;341                public override Task ExitAsync(LauncherBase p, TimeSpan timeout) => Exiting.EnterFromAsync(p, this, timeout);342                public override Task KillAsync(LauncherBase p) => Killing.EnterFromAsync(p, this);343                public override void Dispose(LauncherBase p)344                {345                    p._startCompletionSource.TrySetException(new ObjectDisposedException(p.ToString()));346                    base.Dispose(p);347                }348                private async Task StartCoreAsync(LauncherBase p)349                {350                    var output = new StringBuilder();351                    void OnProcessDataReceivedWhileStarting(object sender, DataReceivedEventArgs e)352                    {353                        if (e.Data != null)354                        {355                            output.AppendLine(e.Data);356                            var match = Regex.Match(e.Data, "^DevTools listening on (ws:\\/\\/.*)");357                            if (match.Success)358                            {359                                p._startCompletionSource.TrySetResult(match.Groups[1].Value);360                            }361                        }362                    }363                    void OnProcessExitedWhileStarting(object sender, EventArgs e)364                        => p._startCompletionSource.TrySetException(new ProcessException($"Failed to launch Base! {output}"));365                    void OnProcessExited(object sender, EventArgs e) => Exited.EnterFrom(p, p._currentState);366                    p.Process.ErrorDataReceived += OnProcessDataReceivedWhileStarting;367                    p.Process.Exited += OnProcessExitedWhileStarting;368                    p.Process.Exited += OnProcessExited;369                    CancellationTokenSource cts = null;370                    try371                    {372                        p.Process.Start();373                        await Started.EnterFromAsync(p, this).ConfigureAwait(false);374                        p.Process.BeginErrorReadLine();375                        int timeout = p._options.Timeout;376                        if (timeout > 0)377                        {378                            cts = new CancellationTokenSource(timeout);379                            cts.Token.Register(() => p._startCompletionSource.TrySetException(380                                new ProcessException($"Timed out after {timeout} ms while trying to connect to Base!")));381                        }382                        try383                        {384                            await p._startCompletionSource.Task.ConfigureAwait(false);385                            await Started.EnterFromAsync(p, this).ConfigureAwait(false);386                        }387                        catch388                        {389                            await Killing.EnterFromAsync(p, this).ConfigureAwait(false);390                            throw;391                        }392                    }393                    finally394                    {395                        cts?.Dispose();396                        p.Process.Exited -= OnProcessExitedWhileStarting;397                        p.Process.ErrorDataReceived -= OnProcessDataReceivedWhileStarting;398                    }399                }400            }401            private class StartedState : State402            {403                public Task EnterFromAsync(LauncherBase p, State fromState)404                {405                    if (TryEnter(p, fromState))406                    {407                    }408                    return Task.CompletedTask;409                }410                protected override void Leave(LauncherBase p) { }411                public override Task StartAsync(LauncherBase p) => Task.CompletedTask;412                public override Task ExitAsync(LauncherBase p, TimeSpan timeout) => Exiting.EnterFromAsync(p, this, timeout);413                public override Task KillAsync(LauncherBase p) => Killing.EnterFromAsync(p, this);414            }415            private class ExitingState : State416            {417                public Task EnterFromAsync(LauncherBase p, State fromState, TimeSpan timeout)418                    => !TryEnter(p, fromState) ? p._currentState.ExitAsync(p, timeout) : ExitAsync(p, timeout);419                public override async Task ExitAsync(LauncherBase p, TimeSpan timeout)420                {421                    var waitForExitTask = WaitForExitAsync(p);422                    await waitForExitTask.WithTimeout(423                        async () =>424                        {425                            await Killing.EnterFromAsync(p, this).ConfigureAwait(false);426                            await waitForExitTask.ConfigureAwait(false);427                        },428                        timeout,429                        CancellationToken.None).ConfigureAwait(false);430                }431                public override Task KillAsync(LauncherBase p) => Killing.EnterFromAsync(p, this);432            }433            private class KillingState : State434            {435                public async Task EnterFromAsync(LauncherBase p, State fromState)436                {437                    if (!TryEnter(p, fromState))438                    {439                        // Delegate KillAsync to current state, because it has already changed since440                        // transition to this state was initiated.441                        await p._currentState.KillAsync(p).ConfigureAwait(false);442                    }443                    try444                    {445                        if (!p.Process.HasExited)446                        {447                            p.Process.Kill();448                        }449                    }450                    catch (InvalidOperationException)451                    {452                        // Ignore453                        return;454                    }455                    await WaitForExitAsync(p).ConfigureAwait(false);456                }457                public override Task ExitAsync(LauncherBase p, TimeSpan timeout) => WaitForExitAsync(p);458                public override Task KillAsync(LauncherBase p) => WaitForExitAsync(p);459            }460            private class ExitedState : State461            {462                public void EnterFrom(LauncherBase p, State fromState)463                {464                    while (!TryEnter(p, fromState))465                    {466                        // Current state has changed since transition to this state was requested.467                        // Therefore retry transition to this state from the current state. This ensures468                        // that Leave() operation of current state is properly called.469                        fromState = p._currentState;470                        if (fromState == this)471                        {472                            return;473                        }474                    }...

...11            Starting = new ChromiumStartingState(this);12            Started = new StartedState(this);13            Exiting = new ExitingState(this);14            Killing = new KillingState(this);15            Exited = new ExitedState(this);16            Disposed = new DisposedState(this);17            CurrentState = Initial;18        }19        public State CurrentState20        {21            get => _currentState;22            set => _currentState = value;23        }24        internal State Initial { get; set; }25        internal State Starting { get; set; }26        internal StartedState Started { get; set; }27        internal State Exiting { get; set; }28        internal State Killing { get; set; }29        internal ExitedState Exited { get; set; }30        internal State Disposed { get; set; }31        public bool TryEnter(LauncherBase p, State fromState, State toState)32        {33            if (Interlocked.CompareExchange(ref _currentState, toState, fromState) == fromState)34            {35                fromState.Leave(p);36                return true;37            }38            return false;39        }40    }41}...

1using System;2using System.Threading.Tasks;3namespace PuppeteerSharp.States4{5    internal class ExitedState : State6    {7        public ExitedState(StateManager stateManager) : base(stateManager)8        {9        }10        public void EnterFrom(LauncherBase p, State fromState)11        {12            while (!StateManager.TryEnter(p, fromState, this))13            {14                // Current state has changed since transition to this state was requested.15                // Therefore retry transition to this state from the current state. This ensures16                // that Leave() operation of current state is properly called.17                fromState = StateManager.CurrentState;18                if (fromState == this)19                {20                    return;21                }...

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            var browser = await Puppeteer.LaunchAsync(new LaunchOptions9            {10                Args = new string[] { "--start-maximized" }11            });12            var page = await browser.NewPageAsync();13            await page.WaitForSelectorAsync("input[name='q']");14            await page.TypeAsync("input[name='q']", "puppeteer");15            await page.Keyboard.PressAsync("Enter");16            await page.WaitForNavigationAsync();17            await page.WaitForSelectorAsync("h3.LC20lb");18            var exitedState = new ExitedState();19            exitedState.State = "exited";20            exitedState.Message = "Test Passed";21            await browser.CloseAsync();22        }23    }24}25using System;26using System.Threading.Tasks;27using PuppeteerSharp;28{29    {30        static async Task Main(string[] args)31        {32            var browser = await Puppeteer.LaunchAsync(new LaunchOptions33            {34                Args = new string[] { "--start-maximized" }35            });36            var page = await browser.NewPageAsync();37            await page.WaitForSelectorAsync("input[name='q']");38            await page.TypeAsync("input[name='q']", "puppeteer");39            await page.Keyboard.PressAsync("Enter");40            await page.WaitForNavigationAsync();41            await page.WaitForSelectorAsync("h3.LC20lb");42            var exitedState = new ExitedState();43            exitedState.State = "exited";44            exitedState.Message = "Test Passed";45            await browser.CloseAsync();46        }47    }48}49using System;50using System.Threading.Tasks;51using PuppeteerSharp;52{53    {54        static async Task Main(string[] args)55        {

1using PuppeteerSharp.States;2using System.Threading.Tasks;3{4    {5        public ExitedState(Browser browser) : base(browser)6        {7        }8        public override Task CloseAsync()9        {10            return Task.CompletedTask;11        }12        public override Task ConnectAsync()13        {14            return Task.CompletedTask;15        }16        public override Task DisconnectAsync()17        {18            return Task.CompletedTask;19        }20        public override Task KillAsync()21        {22            return Task.CompletedTask;23        }24        public override Task LaunchAsync()25        {26            return Task.CompletedTask;27        }28    }29}30using PuppeteerSharp.States;31using System.Threading.Tasks;32{33    {34        public ExitedState(Browser browser) : base(browser)35        {36        }37        public override Task CloseAsync()38        {39            return Task.CompletedTask;40        }41        public override Task ConnectAsync()42        {43            return Task.CompletedTask;44        }45        public override Task DisconnectAsync()46        {47            return Task.CompletedTask;48        }49        public override Task KillAsync()50        {51            return Task.CompletedTask;52        }53        public override Task LaunchAsync()54        {55            return Task.CompletedTask;56        }57    }58}59using PuppeteerSharp.States;60using System.Threading.Tasks;61{62    {63        public ExitedState(Browser browser) : base(browser)64        {65        }66        public override Task CloseAsync()67        {68            return Task.CompletedTask;69        }70        public override Task ConnectAsync()71        {72            return Task.CompletedTask;73        }74        public override Task DisconnectAsync()75        {76            return Task.CompletedTask;77        }78        public override Task KillAsync()79        {80            return Task.CompletedTask;81        }82        public override Task LaunchAsync()83        {84            return Task.CompletedTask;85        }86    }87}88using PuppeteerSharp.States;89using System.Threading.Tasks;

1using PuppeteerSharp.States;2using System.Threading.Tasks;3{4    {5        public ExitedState(Browser browser) : base(browser)6        {7        }8        public override Task CloseAsync()9        {10            return Task.CompletedTask;11        }12        public override Task ConnectAsync()13        {14            return Task.CompletedTask;15        }16        public override Task DisconnectAsync()17        {18            return Task.CompletedTask;19        }20        public override Task KillAsync()21        {22            return Task.CompletedTask;23        }24        public override Task LaunchAsync()25        {26            return Task.CompletedTask;27        }28    }29}30using PuppeteerSharp.States;31using System.Threading.Tasks;32{33    {34        public ExitedState(Browser browser) : base(browser)35        {36        }37        public override Task CloseAsync()38        {39            return Task.CompletedTask;40        }41        public override Task ConnectAsync()42        {43            return Task.CompletedTask;44        }45        public override Task DisconnectAsync()46        {47            return Task.CompletedTask;48        }49        public override Task KillAsync()50        {51            return Task.CompletedTask;52        }53        public override Task LaunchAsync()54        {55            return Task.CompletedTask;56        }57    }58}59using PuppeteerSharp.States;60using System.Threading.Tasks;61{62    {63        public ExitedState(Browser browser) : base(browser)64        {65        }66        public override Task CloseAsync()67        {68            return Task.CompletedTask;69        }70        public override Task ConnectAsync()71        {72            return Task.CompletedTask;73        }74        public override Task DisconnectAsync()75        {76            return Task.CompletedTask;77        }78        public override Task KillAsync()79        {80            return Task.CompletedTask;81        }82        public override Task LaunchAsync()83        {84            return Task.CompletedTask;85        }86    }87}88using PuppeteerSharp.States;89using System.Threading.Tasks;

1using PuppeteerSharp.States;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            var options = new LaunchOptions { Headless = false };9            var browser = await Puppeteer.LaunchAsync(options);10            var page = await browser.NewPageAsync();11            await page.WaitForSelectorAsync("input[name=q]");12            await page.TypeAsync("input[name=q]", "PuppeteerSharp");13            await page.Keyboard.PressAsync("Enter");14            await page.WaitForNavigationAsync(new NavigationOptions { WaitUntil = new[] { WaitUntilNavigation.Networkidle0 } });15            var result = await page.QuerySelectorAsync("h3.LC20lb");16            if (result != null)17            {18                Console.WriteLine("Test Passed");19            }20            {21                Console.WriteLine("Test Failed");22            }23            await browser.CloseAsync();24        }25    }26}27error CS0246: The type or namespace name 'PuppeteerSharp.States' could not be found (are you missing a using directive or an assembly reference?)28error CS0246: The type or namespace name 'PuppeteerSharp.States' could not be found (are you missing a using directive or an assembly reference?)29error CS0246: The type or namespace name 'PuppeteerSharp.States' could not be found (are you missing a using directive or an assembly reference?)30error CS0246: The type or namespace name 'PuppeteerSharp.States' could not be found (are you missing a using directive or an assembly reference?)31error CS0246: The type or namespace name 'PuppeteerSharp.States' could not be found (are you missing a using directive or an assembly reference?)

1var browser = await Puppeteer.LaunchAsync(new LaunchOptions2{3    Args = new string[] { "--window-size=1920,1080" }4});5var page = await browser.NewPageAsync();6await page.WaitForSelectorAsync("input[name='q']");7await page.TypeAsync("input[name='q']", "PuppeteerSharp");8await page.WaitForSelectorAsync("input[name='btnK']");9await page.ClickAsync("input[name='btnK']");10await page.WaitForSelectorAsync("div#search");11await page.WaitForTimeoutAsync(5000);12await page.ScreenshotAsync("image.png");13await browser.CloseAsync();

1var browser = await Puppeteer.LaunchAsync(new LaunchOptions2{3    Args = new string[] { "--window-size=1920,1080" }4});5var page = await browser.NewPageAsync();6await page.WaitForSelectorAsync("input[name='q']");7await page.TypeAsync("input[name='q']", "PuppeteerSharp");8await page.WaitForSelectorAsync("input[name='btnK']");9await page.ClickAsync("input[name='btnK']");10await page.WaitForSelectorAsync("div#search");11await page.WaitForTimeoutAsync(5000);12await page.ScreenshotAsync("image.png");13await browser.CloseAsync();

1using PuppeteerSharp.States;2using PuppeteerSharp;3using System.Threading.Tasks;4using System;5{6    {7        public override Task CloseAsync(Browser browser) => Task.CompletedTask;8        public override Task<BrowserContext> CreateIncognitoBrowserContextAsync(Browser browser) => throw new PuppeteerException("Protocol error (Target.createBrowserContext): Target closed.");9        public override Task<BrowserContext[]> BrowserContextsAsync(Browser browser) => throw new PuppeteerException("Protocol error (Target.getBrowserContexts): Target closed.");10        public override Task<BrowserContext> DefaultBrowserContextAsync(Browser browser) => throw new PuppeteerException("Protocol error (Target.getBrowserContexts): Target closed.");11        public override Task DisconnectAsync(Browser browser) => Task.CompletedTask;12        public override Task<bool> IsConnectedAsync(Browser browser) => Task.FromResult(false);13        public override Task<Page[]> PagesAsync(Browser browser) => throw new PuppeteerException("Protocol error (Target.getTargets): Target closed.");14        public override Task<Page> WaitForTargetAsync(Browser browser, Func<Target, bool> predicate, TargetChangedOptions options) => throw new PuppeteerException("Protocol error (Target.getTargets): Target closed.");15        public override Task<CDPSession> CreateCDPSessionAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.attachToTarget): Target closed.");16        public override Task<string> TargetTypeAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.getTargetInfo): Target closed.");17        public override Task<string> TargetUrlAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.getTargetInfo): Target closed.");18        public override Task<string> TargetTitleAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.getTargetInfo): Target closed.");19        public override Task<Page> PageAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.getTargetInfo): Target closed.");20        public override Task<Worker> WorkerAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol error (Target.getTargetInfo): Target closed.");21        public override Task<BrowserContext> BrowserContextAsync(Browser browser, Target target) => throw new PuppeteerException("Protocol

1var exitedState = new ExitedState();2var browser = await Puppeteer.LaunchAsync(new LaunchOptions3{4    Args = new string[] { "--disable-gpu", "--no-sandbox", "--disable-setuid-sandbox" },5    ExecutablePath = @"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",6});7var page = await browser.NewPageAsync();8await page.ScreenshotAsync("google.png");9await browser.CloseAsync();10var exitedState = new ExitedState();11var browser = await Puppeteer.LaunchAsync(new LaunchOptions12{13    Args = new string[] { "--disable-gpu", "--no-sandbox", "--disable-setuid-sandbox" },14    ExecutablePath = @"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",

1using PuppeteerSharp.States;2using PuppeteerSharp;3using System.Threading.Tasks;4{5    {6        public void Dispose()7        {8        }9    }10}11using PuppeteerSharp.States;12using PuppeteerSharp;13using System.Threading.Tasks;14{15    {16        public void Dispose()17        {18        }19    }20}21using PuppeteerSharp.States;22using PuppeteerSharp;23using System.Threading.Tasks;24{25    {26        public void Distose()27        {28        }29    }30}31using PuppeteerSharp.States;32using PuppeteerSharp;33using System.Threading.Tasks;34{35    {36        public void Dispose()37        {38        }39    }40}41using PuppeteerSharp.States;42using PuppeteerSharp;43using System.Threading.Tasks;44{45    {46        public void Dispose()47        {48        }49    }50}51using PuppeteerSharp.States;52using PuppeteerSharp;53using System.Threading.Tasks;54{55    {56        public void Dispose()57        {58        }59    }60}61using PuppeteerSharp.States;62using PuppeteerSharp;63using System.Threading.Tasks;64});65var page = await browser.NewPageAsync();66await page.ScreenshotAsync("google.png");67await browser.CloseAsync();68var exitedState = new ExitedState();69var browser = await Puppeteer.LaunchAsync(new LaunchOptions70{71    Args = new string[] { "--disable-gpu", "--no-sandbox", "--disable-setuid-sandbox" },72    ExecutablePath = @"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",73});74var page = await browser.NewPageAsync();75await page.ScreenshotAsync("google.png");76await browser.CloseAsync();77var exitedState = new ExitedState();78var browser = await Puppeteer.LaunchAsync(new LaunchOptions79{80    Args = new string[] { "--disable-gpu", "--no-sandbox", "--disable-setuid-sandbox" },

1using PuppeteerSharp.States;2using PuppeteerSharp;3using System.Threading.Tasks;4{5    {6        public void Dispose()7        {8        }9    }10}11using PuppeteerSharp.States;12using PuppeteerSharp;13using System.Threading.Tasks;14{15    {16        public void Dispose()17        {18        }19    }20}21using PuppeteerSharp.States;22using PuppeteerSharp;23using System.Threading.Tasks;24{25    {26        public void Dispose()27        {28        }29    }30}31using PuppeteerSharp.States;32using PuppeteerSharp;33using System.Threading.Tasks;34{35    {36        public void Dispose()37        {38        }39    }40}41using PuppeteerSharp.States;42using PuppeteerSharp;43using System.Threading.Tasks;44{45    {46        public void Dispose()47        {48        }49    }50}51using PuppeteerSharp.States;52using PuppeteerSharp;53using System.Threading.Tasks;54{55    {56        public void Dispose()57        {58        }59    }60}61using PuppeteerSharp.States;62using PuppeteerSharp;63using System.Threading.Tasks;