Many Forms – What is Polymorphism

The word Polymorphism comes from Greek and literally means "many forms." In Object-Oriented Programming, it's one of the core pillars, and it describes the ability of objects of different classes to respond to the same method call in different, class-specific ways.

The key idea is that you can have a variable of a base class type that holds an object of a derived class type. When you call a method on that variable, the .NET runtime is smart enough to execute the version of the method belonging to the actual object's derived class, not the base class version.

Here's a classic analogy: imagine a list of Animal objects. This single list can hold a Dog object, a Cat object, and a Duck object because they all are animals (they inherit from the Animal base class). If you loop through this list and call an animal.MakeSound() method on each one:

• The Dog object will execute its specific sound method and print "Woof!"
• The Cat object will execute its version and print "Meow."
• The Duck object will execute its version and print "Quack!"

You treat them all the same (as an Animal), but they each respond with their own unique form of the behavior. This makes your code incredibly flexible and extensible.

Unlocking Polymorphism with virtual

This polymorphic behavior doesn't happen automatically for every method in C#. You have to explicitly signal your intent. To allow a method in a base class to be overridden by a child class, you must mark it with the virtual keyword.

Marking a method as virtual says, "Derived classes are welcome to provide their own specific version of this method if they want to, but if they don't, they'll just use this default implementation."

Let's update our UserAccount base class from the previous lesson to include a virtual method:

public class UserAccount
{
    public string Username { get; set; }
 
    // ... other properties and constructor ...
 
    // We mark this method as 'virtual' to allow derived classes to override it.
    public virtual void DisplayGreeting()
    {
        Console.WriteLine($"Welcome, {Username}! (Standard User)");
    }
}   

Now, the DisplayGreeting method is open for specialization by any class that inherits from UserAccount.

Modifying Behavior with override

Once a method in a base class is marked as virtual, a derived class can provide its own unique implementation for that method. To do this, the method in the derived class must be marked with the override keyword. The method signature (name, parameters, and return type) must be identical to the virtual method in the base class.

Using override tells the C# compiler, "I know there's a version of this method in my parent class, but I am intentionally providing a new, specialized version for this child class."

Let's update our AdminUser and create a GuestUser class to provide their own greetings:

public class AdminUser : UserAccount
{
    // ... constructor and other members ...
 
    // We 'override' the base class's virtual method
    public override void DisplayGreeting()
    {
        Console.WriteLine($"Greetings, Administrator {Username}! System access granted.");
    }
}
 
public class GuestUser : UserAccount
{
    // ... constructor ...
 
    public override void DisplayGreeting()
    {
        Console.WriteLine("Welcome, Guest! Your access is limited.");
    }
}   

Now, when we call DisplayGreeting() on an AdminUser object, it will run this specialized version, not the one from UserAccount.

Polymorphism in Action

This is where the magic truly shines. We can now create a collection – like a List<UserAccount> – that holds different kinds of user objects, and treat them all uniformly.

// Assume UserAccount, AdminUser, and GuestUser classes are defined as above
// (with constructors that take a username)
 
// Create a list that holds UserAccount objects
List<UserAccount> allUsers = new List<UserAccount>();
 
// Add different types of objects to the same list!
allUsers.Add(new UserAccount("StandardDan"));
allUsers.Add(new AdminUser("SuperAdmin"));
allUsers.Add(new GuestUser("Visitor123"));
 
Console.WriteLine("--- Processing all users ---");
 
// Loop through the list and call the same method on each object
foreach (UserAccount user in allUsers)
{
    // The .NET runtime determines the object's ACTUAL type at runtime
    // and calls the correct overridden method!
    user.DisplayGreeting();
}
 
Console.ReadLine();

Expected Output:

--- Processing all users ---
Welcome, StandardDan! (Standard User)
Greetings, Administrator SuperAdmin! System access granted.
Welcome, Guest! Your access is limited.

Look at that! Even though our loop variable user is of type UserAccount, when the loop gets to the AdminUser object, it executes the overridden AdminUser version of DisplayGreeting(). This is polymorphism in action. It allows us to write more generic, flexible code that doesn't need to know the specific derived type of an object to work with it.

This dramatically simplifies our code. We didn't need any if statements to check the type of each user; the object-oriented system handled it for us.

Why Polymorphism is Crucial for Test Automation

Polymorphism is not just an academic concept; it's incredibly practical for building flexible and maintainable test automation frameworks.

Imagine you're testing an e-commerce site with different types of product pages: one for books, one for electronics, one for clothing. They share common elements (like a price and an "Add to Cart" button) but also have unique interactions.

You could create a base page object class called BaseProductPage and then have derived classes like BookPage and ElectronicsPage.

public class BaseProductPage
{
    public virtual void AddToCart()
    {
        // Default "Add to Cart" logic
    }
}
 
public class ElectronicsPage : BaseProductPage
{
    public override void AddToCart()
    {
        // Specialized logic: Click "Add to Cart", then also select an extended warranty option.
    }
}
 
public class BookPage : BaseProductPage
{
    public override void AddToCart()
    {
        // Specialized logic: Click "Add to Cart", then also select format (hardcover/paperback).
    }
}   

Your test script can now work with a variable of type BaseProductPage. When it calls productPage.AddToCart(), polymorphism ensures the correct, specialized logic for either the electronics or book page is executed. This allows you to write more generic tests that can handle different page variations gracefully.