Selenium C# Tutorial: Using Explicit and Fluent Wait in Selenium
Tags: csharp, testing, selenium
Published: 2020-05-05 10:13:23

---
title: Selenium C# Tutorial: Using Explicit and Fluent Wait in Selenium
published: true
description: Learn what is explicit and fluent wait in Selenium and how to implement them for your test automation scripts in Selenium C# with examples.
tags: csharp, testing, selenium, 
canonical_url: https://www.lambdatest.com/blog/explicit-fluent-wait-in-selenium-c/
cover_image: https://www.lambdatest.com/blog/wp-content/uploads/2020/03/C-Sharp.jpg
---

Wait is an important command used in [Selenium test automation](https://www.lambdatest.com/selenium-automation?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-5052020&utm_term=Himanshu) for handling dynamic loading of web elements on a web page (or web application). Wait command in Selenium helps to ensure that our web application is less flaky and is more reliable.

In the previous section of this Selenium C# tutorial, we discussed the basics of Selenium Wait and implicit wait command.

In this Selenium C# tutorial i’m going to walk you through two more types of Selenium waits in the WebDriver – Explicit wait and Fluent waits.

***Check out this list of 70*** [***Cucumber Interview Questions***](https://www.lambdatest.com/learning-hub/cucumber-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may03_bh&utm_term=bh&utm_content=learning_hub) ***and Answers that will help you boost your confidence in an Interview.***

## What is Explicit Wait in Selenium C#

Unlike implicit wait, explicit wait in Selenium will wait for certain conditions to occur. The conditions could be waiting for the presence of the web element, waiting for the element to be clickable, waiting for the element to be visible, etc.

Explicit wait in Selenium is also called smart wait as the wait is not for the maximum time-out. If the condition for explicit wait is satisfied, the wait condition is exited and the execution proceeds with the next line of code. Depending on the test scenario, you should choose the best-suited wait condition for explicit wait.

Unlike implicit wait that applies till the time the Selenium WebDriver instance (or IWebDriver object) is alive, explicit wait in Selenium works only on the particular web element on which it is set, rather than all the elements on the page.

Explicit wait in Selenium can be used in test scenarios where synchronization is needed i.e. loading of the web page is complete and you are waiting for the element (under test) to be visible.

The figure shows what happens under the hoods when explicit wait in Selenium is triggered:

![Explicit Wait](https://www.lambdatest.com/blog/wp-content/uploads/2020/03/Explicit-Wait.png)

These steps are followed in sequence when Explicit Wait command is executed:

- The wait time is entered as a part of explicit wait command [e.g. WebDriverWait wait = WebDriverWait(driver, TimeSpan.FromSeconds(10));]
- Condition mentioned in .until() method is checked
- If the condition is not satisfied, a thread sleep is called at the frequency mentioned in the .pollingInterval property. By default, the polling interval is 250 ms.
- Step (c) is repeated till the timeout of the wait time mentioned in step (a) or exit before timeout is performed, if required web element is located. The status of .until() condition is monitored at the end of every polling duration. 

***Get ready for your BDD interview with 100+*** [***BDD interview questions***](https://www.lambdatest.com/learning-hub/bdd-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may03_bh&utm_term=bh&utm_content=learning_hub)***. Boost your confidence and impress your interviewer with this comprehensive guide covering principles & techniques.***

## Features of Explicit Wait in Selenium

Apart from explicit wait, developers also have the choice of using implicit wait command in Selenium C#. Explicit wait in Selenium has a number of key features (or differences) than other types of Selenium waits

- Unlike implicit wait, the explicit wait command in Selenium is documented and has a defined behavior.
- Explicit wait executes on the local part of Selenium i.e. the programming language of your code, whereas implicit wait works on the remote part of Selenium i.e. the one controlling the web browser.
- It can work with any possible condition (e.g. elementToBeClickable, alertIsPresent, invisibilityOfElementWithText, , stalenessOf, etc.) unlike implicit wait that only works on findelement methods.
- Explicit wait in Selenium can also be used in case you are checking for the absence of a web element on the page.
- The delay between retries can be customized using adjusting the .pollingInterval property which is by default set to 250 ms. On the other hand, delay in implicit waits can only be customized through the global timeout.
 

## WebDriverWait and ExpectedCondition

Explicit wait in Selenium is facilitated by WebDriverWait and ExpectedCondition classes. WebDriverWait is present in the OpenQA.Selenium.Support.UI namespace in C#. ExpectedCondition provides a set of conditions on which wait can be performed.

When a search process for a particular web element is performed, the Selenium WebDriver polls the browser for the presence of the element in the DOM (Document Object Model). Below are some of the exceptional situations:

- **NoSuchElementException** – The element is not present in the DOM when the search operation is performed.
- **StaleElementReferenceException** – The web element is present in the DOM when the search is initiated but the element might have become stale (or its state in the DOM could have changed) when the search call is made.
- **ElementNotVisibleException** – The web element is present in the DOM but it is not yet visible when the search process is initiated.
- **ElementNotSelectableException** – The element is present on the page but it cannot be selected.
- **NoSuchFrameException** – The WebDriver tries switching to a frame which is not a valid one.
- **NoAlertPresentException** – The WebDriver attempts switching to an alert window which is not yet available.
- **NoSuchWindowException** – The WebDriver attempts switching to a window that is not a valid one.

For avoiding these exceptions, the description of the exception should be passed to the IgnoreExceptionTypes() method

```
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
wait.IgnoreExceptionTypes(typeof(NoSuchElementException));
```
 
ExpectedConditions class in Selenium C# supplies a set of conditions that can be waited for using WebDriverWait. ExpectedConditions is present in the OpenQA.Selenium.Support.UI.ExpectedConditions namespace.

Some of the common methods exposed by the ExpectedConditions class:

- AlertIsPresent()
- ElementIsVisible()
- ElementExists()
- ElementToBeClickable(By)
- ElementToBeClickable(IWebElement)
- ElementToBeSelected(By)
- ElementToBeSelected(IWebElement)
- ElementToBeSelected(IWebElement, Boolean)
- TitleContains()
- UrlContains()
- UrlMatches()
- VisibilityOfAllElementsLocatedBy(By)
- VisibilityOfAllElementsLocatedBy(ReadOnlyCollection)
- StalenessOf(IWebElement)
- TextToBePresentInElement()
- TextToBePresentInElementValue(IWebElement, String)

More details about the ExpectedConditions class can be found here.

Take this certification to master the fundamentals of Selenium automation testing with C# and prove your credibility as a tester.

Here’s a short glimpse of the Selenium C# 101 certification from LambdaTest:

{% youtube ZU85Mjwgv54 %}

***Ace your Protractor interview with these 50+*** [***Protractor interview questions.***](https://www.lambdatest.com/learning-hub/protractor-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may03_bh&utm_term=bh&utm_content=learning_hub) ***Boost you confidence and land your dream job with this comprehensive guide.***

## Demonstration of Explicit Wait in Selenium C#

To demonstrate the usage of explicit wait in Selenium C#, we perform a search for LambdaTest on Google. For the examples demonstrated in this Selenium C# tutorial, we use the NUnit test framework.

```
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.Support.UI;
using SeleniumExtras.WaitHelpers;
using System;
 
namespace Selenium_ExplicitWait_Demo
{
    class Selenium_ExplicitWait_Demo
    {
        String test_url = "https://www.google.com/ncr";
 
        IWebDriver driver;
 
        [SetUp]
        public void start_Browser()
        {
            // Local Selenium WebDriver
            driver = new ChromeDriver();
            driver.Manage().Window.Maximize();
        }
 
        [Test]
        public void test_search()
        {
            String target_xpath = "//h3[.='LambdaTest: Cross Browser Testing Tools | Free Automated ...']";
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
            driver.Url = test_url;
            driver.FindElement(By.Name("q")).SendKeys("LambdaTest" + Keys.Enter);
 
            /* IWebElement firstResult = driver.FindElement(By.XPath(target_xpath)); */
            IWebElement SearchResult = wait.Until(SeleniumExtras.WaitHelpers.ExpectedConditions.ElementExists(By.XPath(target_xpath)));
 
            SearchResult.Click();
        }
 
        [TearDown]
        public void close_Browser()
        {
            driver.Quit();
        }
    }
}
```
 

The OpenQA.Selenium.Support.UI & SeleniumExtras.WaitHelpers namespaces are included to use WebDriverWait and ExpectedConditions respectively.

An explicit wait in Selenium with a timeout of 10 seconds is set using the WebDriverWait class.

 
```
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
```
 

The ExpectedCondition used is ElementExists. An explicit wait in Selenium is performed till the time the required web element is not found (via XPath) or a timeout occurs i.e. the web element does not exist on the DOM.

 
```
IWebElement SearchResult = wait.Until(SeleniumExtras.WaitHelpers.ExpectedConditions.ElementExists(By.XPath(target_xpath)));
```

As shown in the VS-2019 screenshot, the target web page (LambdaTest Home Page) opens up after search and the test result is Success.

![C#result](https://www.lambdatest.com/blog/wp-content/uploads/2020/03/Cresult.png)

Now that we’ve covered what is explicit wait in Selenium test Automation and what are its features in this Selenium C# tutorial. We’ll now move onto the fluent wait in Selenium and discuss it in further detail.
 
## What is Fluent Wait in Selenium C#

Fluent Wait is another Wait variant in Selenium C# that lets you control the maximum amount of time the Selenium WebDriver needs to wait for the defined condition to appear. [Fluent Wait functionality in Selenium C#](https://groups.google.com/forum/#!topic/webdriver/FsNt15pcXkU) can be achieved by defining the frequency at which the WebDriver checks for the element before it throws ElementNotVisibleException.

One major difference between fluent wait and explicit wait in Selenium test automation is that the polling frequency (.pollingInterval) at which the presence for the web element is checked is controllable in fluent wait in Selenium, whereas it is 250 ms in explicit wait.

If the polling frequency in fluent wait is not set, it defaults to 250 ms. The user also has the flexibility to ignore exceptions that may occur during the polling period using the IgnoreExceptionTypes command. The [DefaultWait class in C#](https://www.selenium.dev/selenium/docs/api/dotnet/html/T_OpenQA_Selenium_Support_UI_DefaultWait_1.htm) is used to configure the timeout and polling interval on the fly.

**Syntax of Fluent Wait command in Selenium C#**

```
/
* Selenium C# tutorial-Syntax of Fluent Wait in Selenium*/

/* DefaultWait Class used to control timeout and polling frequency */
/* /* https://www.selenium.dev/selenium/docs/api/dotnet/html/T_OpenQA_Selenium_Support_UI_DefaultWait_1.htm */
DefaultWait<IWebDriver> fluentWait = new DefaultWait<IWebDriver>(driver);
 
/* Setting the timeout in seconds */
fluentWait.Timeout = TimeSpan.FromSeconds(5);
 
/* Configuring the polling frequency in ms */
fluentWait.PollingInterval = TimeSpan.FromMilliseconds(polling_interval_in_ms);
```


## Demonstration of Fluent Wait in Selenium C#

To demonstrate fluent wait in Selenium test automation, the same test scenario which we used for explicit wait in Selenium, i.e. searching for LambdaTest on Google and clicking on the matching result.

```
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.Support.UI;
using SeleniumExtras.WaitHelpers;
using System;
 
namespace Selenium_ExplicitWait_Demo
{
    class Selenium_ExplicitWait_Demo
    {
        String test_url = "https://www.google.com/ncr";
 
        IWebDriver driver;
 
        [SetUp]
        public void start_Browser()
        {
            // Local Selenium WebDriver
            driver = new ChromeDriver();
            driver.Manage().Window.Maximize();
        }
 
        [Test]
        public void test_search()
        {
            String target_xpath = "//h3[.='LambdaTest: Cross Browser Testing Tools | Free Automated ...']";
 
            /* Explicit Wait */
            /* WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); */
 
            DefaultWait<IWebDriver> fluentWait = new DefaultWait<IWebDriver>(driver);
            fluentWait.Timeout = TimeSpan.FromSeconds(5);
            fluentWait.PollingInterval = TimeSpan.FromMilliseconds(250);
            /* Ignore the exception - NoSuchElementException that indicates that the element is not present */
            fluentWait.IgnoreExceptionTypes(typeof(NoSuchElementException));
            fluentWait.Message = "Element to be searched not found";
 
            driver.Url = test_url;
            driver.FindElement(By.Name("q")).SendKeys("LambdaTest" + Keys.Enter);
 
            /* Explicit Wait */
            /* IWebElement SearchResult = wait.Until(SeleniumExtras.WaitHelpers.ExpectedConditions.ElementExists(By.XPath(target_xpath))); */
            IWebElement searchResult = fluentWait.Until(x => x.FindElement(By.XPath(target_xpath)));
            searchResult.Click();
        }
 
        [TearDown]
        public void close_Browser()
        {
            driver.Quit();
        }
    }
}
```
 

The polling frequency is set to 250 ms and timeout for locating the web element is set to 5 seconds. NoSuchElementException is ignored in case if the web element is not found on the DOM.

```
DefaultWait<IWebDriver> fluentWait = new DefaultWait<IWebDriver>(driver);
fluentWait.Timeout = TimeSpan.FromSeconds(5);
fluentWait.PollingInterval = TimeSpan.FromMilliseconds(250);
/* Ignore the exception -NoSuchElementException that indicates that the element is not present */
fluentWait.IgnoreExceptionTypes(typeof(NoSuchElementException));
fluentWait.Message = "Element to be searchDefaultWaited not found";
```
 

The .until() method is used to search for the intended web element. The element is searched till the timeout (of 5 seconds) happens or until the element is found.

```
IWebElement searchResult = fluentWait.Until(x => x.FindElement(By.XPath(target_xpath)));
```

As seen in the execution snapshot; the element is found, the target page (LambdaTest homepage) is opened, and the WebDriver session is terminated.

![Final result](https://www.lambdatest.com/blog/wp-content/uploads/2020/03/Final-result.png)

***If you are preparing for a Playwright automation interview, this list of*** [***Playwright interview questions***](https://www.lambdatest.com/learning-hub/playwright-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may03_bh&utm_term=bh&utm_content=learning_hub) ***can help you get a list of the most asked questions with detailed answers***

## Wrapping it up

In this Selenium C# tutorial, we had a detailed look at explicit and fluent wait in Selenium. Both explicit and fluent wait in Selenium are ideal for performing waits on web elements in modern day websites as the wait can be used alongside ExpectedConditions.

Explicit and Fluent wait in Selenium look for the presence of the web element at regular intervals till the element is found or there is a timeout occurrence. By using Fluent wait in Selenium test automation, you can control the polling frequency (which is set default to 250 ms) and also configure exceptions that have to be ignored during the polling period.

So far in our Selenium C# tutorials we’ve covered How to set up Selenium in visual Studio, Implicit wait in Selenium. There is a lot more content we’ve planned for this series, also if there’s any topic you want us to cover, do let us know.

**Happy Testing** ☺