Selenium C#: Selecting Dropdown Value With POM

Oct 17, 2025 by Dimemap Team 47 views

Selecting Dropdown Value with Selenium C# and Page Object Model

Hey guys! So, you're diving into Selenium with C# and trying to wrangle dropdown lists using the Page Object Model (POM)? Awesome! It's a fantastic way to keep your tests organized and maintainable. Let's break down how to nail those dropdown selections. I will show you how to select an element value from a drop-down list with selenium using POM.

Understanding the Page Object Model

First off, let's quickly recap what the Page Object Model is all about. POM is a design pattern that creates an object repository for web UI elements. Each page in your application gets its own class, and all the elements and actions you can perform on that page are defined within that class. This makes your test code cleaner, more readable, and easier to maintain. Think of it as giving each webpage its own little instruction manual.

Why is this important for dropdowns? Well, dropdowns can sometimes be tricky. They might be standard <select> elements, or they could be custom-built using <div> or <ul> tags. POM helps you abstract away these implementation details, so your tests don't need to know how the dropdown is built, just what to do with it.

Setting Up Your Project

Before we dive into the code, make sure you have a few things set up:

Selenium WebDriver: You'll need the Selenium WebDriver package for C#. You can grab it via NuGet Package Manager in Visual Studio.
WebDriver Instance: Make sure you have a WebDriver instance initialized. This is what Selenium uses to control your browser (e.g., ChromeDriver, FirefoxDriver).
Page Object Classes: Create the page object classes for the pages you're interacting with. This is where you'll define your elements and methods.

Inspecting the Dropdown

Okay, let's talk strategy. The first thing you need to do is inspect the dropdown in your browser's developer tools. Right-click on the dropdown and select "Inspect" (or "Inspect Element"). This will show you the HTML structure of the dropdown. Look for these common scenarios:

<select> Element: This is the standard HTML dropdown. If you see this, Selenium has built-in support for selecting options.
<div> or <ul> with <li> Elements: Some websites use custom dropdowns built from divs or unordered lists. These require a bit more finesse.

Understanding the underlying HTML is crucial because it dictates how you'll interact with the dropdown using Selenium.

Example Scenario: Registering on Midomi.com

Since you mentioned you're working with midomi.com, let's use that as our example. I am trying to make a simple test to register in website - https://www.midomi.com/. I am using c# and selenium but have stuck in selecting values from a dropdown list using Page object model. Pretend we're automating the registration process and need to select a country from a dropdown list. We'll create a RegistrationPage object in our POM structure.

Creating the Page Object

First, let's create the RegistrationPage class. This class will hold all the elements and methods related to the registration page.

using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;

public class RegistrationPage
{
    private IWebDriver _driver;
    private By _countryDropdownLocator = By.Id("country"); // Replace with the actual ID or selector

    public RegistrationPage(IWebDriver driver)
    {
        _driver = driver;
    }

    public void SelectCountry(string countryName)
    {
        // Implementation will go here
    }
}

In this code:

We have a _driver field to hold our WebDriver instance.
We define a _countryDropdownLocator using By.Id. Make sure to replace "country" with the actual ID or CSS selector of your dropdown.
We have a SelectCountry method that will handle the selection logic.

Selecting from a Standard `<select>` Element

If your dropdown is a standard <select> element, you can use the SelectElement class from OpenQA.Selenium.Support.UI. This class provides handy methods for selecting options by text, value, or index.

Here’s how you can implement the SelectCountry method:

using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;

public class RegistrationPage
{
    private IWebDriver _driver;
    private By _countryDropdownLocator = By.Id("country"); // Replace with the actual ID or selector

    public RegistrationPage(IWebDriver driver)
    {
        _driver = driver;
    }

    public void SelectCountry(string countryName)
    {
        SelectElement countryDropdown = new SelectElement(_driver.FindElement(_countryDropdownLocator));
        countryDropdown.SelectByText(countryName);
    }
}

Explanation:

We find the dropdown element using the _countryDropdownLocator.
We create a SelectElement object, passing in the dropdown element.
We use SelectByText(countryName) to select the option with the matching text. You can also use SelectByValue or SelectByIndex if those are more appropriate for your situation.

Selecting from a Custom Dropdown

If your dropdown is a custom-built one (using <div> or <ul> elements), you'll need a different approach. You'll have to manually click the dropdown to open it and then click the desired option.

Here’s how you might implement this:

using OpenQA.Selenium;

public class RegistrationPage
{
    private IWebDriver _driver;
    private By _countryDropdownLocator = By.CssSelector(".custom-dropdown"); // Replace with the actual selector
    private By _countryOptionLocator = By.XPath("//ul[@class='dropdown-options']/li[text()='{0}']"); // Replace with the actual selector

    public RegistrationPage(IWebDriver driver)
    {
        _driver = driver;
    }

    public void SelectCountry(string countryName)
    {
        // Click the dropdown to open it
        _driver.FindElement(_countryDropdownLocator).Click();

        // Find and click the desired option
        By optionLocator = By.XPath(string.Format(_countryOptionLocator.ToString(), countryName));
        _driver.FindElement(optionLocator).Click();
    }
}

Explanation:

We click the dropdown element to reveal the options.
We construct an XPath to find the <li> element (or whatever element represents the option) that contains the desired text.
We click the option to select it.

Using the Page Object in Your Tests

Now that you have your RegistrationPage object, you can use it in your tests like this:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using NUnit.Framework;

[TestFixture]
public class RegistrationTest
{
    private IWebDriver _driver;
    private RegistrationPage _registrationPage;

    [SetUp]
    public void Setup()
    {
        _driver = new ChromeDriver();
        _driver.Navigate().GoToUrl("https://www.midomi.com/index.php?action=main.register");
        _registrationPage = new RegistrationPage(_driver);
    }

    [Test]
    public void CanRegisterWithValidCountry()
    {
        _registrationPage.SelectCountry("United States");
        // Add assertions to verify the country was selected
    }

    [TearDown]
    public void Teardown()
    {
        _driver.Quit();
    }
}

In this test:

We initialize the ChromeDriver and navigate to the registration page.
We create an instance of RegistrationPage, passing in the _driver.
In the CanRegisterWithValidCountry test, we call the SelectCountry method to select "United States" from the dropdown.
Important: You'll want to add assertions to verify that the country was actually selected. This could involve checking the selected value of the dropdown or verifying that the correct element is now displayed.

Handling Exceptions

Dropdowns can sometimes be finicky, so it's a good idea to handle potential exceptions. For example, the option you're trying to select might not be present, or the dropdown might not be visible. Wrap your selection code in try-catch blocks to handle these cases gracefully.

try
{
    _registrationPage.SelectCountry("Invalid Country");
}
catch (NoSuchElementException ex)
{
    Console.WriteLine("Country not found: " + ex.Message);
    // Handle the exception appropriately (e.g., fail the test, log an error)
}

Best Practices

Here are a few best practices to keep in mind when working with dropdowns in Selenium:

Use Explicit Waits: Wait for the dropdown to be visible and enabled before interacting with it. This prevents timing issues.
Use Clear Selectors: Make sure your locators (IDs, CSS selectors, XPaths) are specific and reliable. Avoid using brittle locators that might break easily.
Test Different Scenarios: Test selecting different options, including the first, last, and middle options. Also, test selecting invalid options to ensure your code handles errors correctly.
Keep Your Page Objects Clean: Keep your page object methods focused and avoid putting too much logic in them. The goal is to abstract away the implementation details of the page.

Final Thoughts

Selecting values from dropdowns using Selenium and the Page Object Model can be a bit tricky, but with the right approach, you can make your tests reliable and maintainable. Remember to inspect the dropdown element, use the appropriate selection method (either SelectElement or manual clicking), and handle exceptions gracefully. Happy testing, and let me know if you have any other questions!