Distinguishing Key Object-Oriented Concepts

In the C# programming language, developers frequently encounter terms related to method reuse and inheritance modification. While often used interchangeably in casual conversation, method overloading, overriding, and member hiding (often confused with "overwriting") represent distinct mechanisms with specific syntactic requirements and runtime behaviors.

Method Overloading

Overloading occurs within a single class scope. It permits multiple methods to share the same identifier provided their parameter lists differ. This allows the compiler to determine which method implementation to invoke based on the types and count of arguments passed during the call. It supports polymorphism at compile time.

public class ReportGenerator
{
    public void Generate()
    {
        Console.WriteLine("Generating default report...");
    }

    public void Generate(string reportType)
    {
        Console.WriteLine($"Generating {reportType} report...");
    }

    public void Generate(string path, bool exportAsPdf)
    {
        Console.WriteLine($"Exporting {path} to PDF: {exportAsPdf}");
    }
}

Above, the Generate method demonstrates three variations. Despite sharing the name, the method resolution engine selects the appropriate version based strictly on the arguments supplied.

Method Overriding

Overriding is a core aspect of runtime polymorphism. It enables a subclass to provide a specialzied implementation for a method already defined in its parent class. To achieve this, the base method must be marked as virtual, abstract, or override, allowing the derived class to modify behavior using the override keyword.

public class BaseSystem
{
    public virtual string GetStatus()
    {
        return "System Status: Normal";
    }
}

public class AdvancedSystem : BaseSystem
{
    public override string GetStatus()
    {
        return "Advanced System Status: Optimized";
    }
}

When calling GetStatus() on an instance of AdvancedSystem, the overridden version executes. This relies on dynamic dispatch to resolve the method call to the actual object type present in memory at runtime.

Member Hiding (The 'New' Keyword)

The concept sometimes referred to as "overwriting" typically maps to member hiding in C#. Unlike overriding, hiding does not interact with inheritance polymorphism. Instead, it creates a new member in the derived class that has the same name as a member in the base class, effective shadowing it. This requires the explicit new modifier to suppress compiler warnings and indicate intentional concealment of the base member.

public class Configuration
{
    public string GetConnectionString()
    {
        return "Standard Connection";
    }
}

public class ProductionConfig : Configuration
{
    // Hides the base member intentionally
    public new string GetConnectionString()
    {
        return "Production Secure Connection";
    }
}

In this scenario, the compiler binds calls statically. Calling GetConnectionString() on a reference typed as Configuration invokes the base implementation, whereas an ProductionConfig reference invokes the hidden version.