OOP in C#: Inheritance, Polymorphism and Abstraction

Object-oriented programming (OOP) is the largest topic in C# interviews. This article follows the questions in the order interviewers usually ask them.

The four pillars in C#

Overloading versus overriding

• Overloading is several methods with the same name and different parameters in one class. The compiler picks one at compile time.
• Overriding replaces a base class method in a derived class (virtual in the base, override in the derived class). The run-time type of the object picks the method. This is runtime polymorphism.

virtual, override and new

Animal a = new Dog();
Console.WriteLine(a.Speak());      // Woof    (override: the run-time type decides)
Console.WriteLine(a.Name());       // Animal  (new only hides: the compile-time type decides)

Dog d = new Dog();
Console.WriteLine(d.Name());       // Dog

public class Animal
{
    public virtual string Speak() => "...";
    public string Name() => "Animal";
}

public class Dog : Animal
{
    public override string Speak() => "Woof";
    public new string Name() => "Dog";      // hides Animal.Name; this is not polymorphism
}

override takes part in polymorphism. new hides a member: calls through a Dog variable see the new method, calls through an Animal variable still see the old one. Method hiding is almost always a design smell. If you see a compiler warning about hiding, decide whether you meant override.

Try it in the virtual, override and new snippet.

Abstract class versus interface

Use an interface for a capability (, , ) and an abstract class when derived classes share code or state.

Can an abstract class have a constructor? Yes. It runs when a derived class is created, so it can initialize shared state. It is usually , because you can never call on the abstract class itself.

Access modifiers

A quick way to remember the last two: is the wider one ("or"), is the narrower one ("and").

Encapsulation with properties

Expose behaviour through properties, not public fields. A property can add validation later without breaking callers:

Static classes and static constructors

• A static class cannot be instantiated or inherited, and contains only static members. Use it for stateless helpers.
• A static constructor runs once, automatically, before the type is first used. It has no access modifier or parameters and you cannot call it yourself.
• Overusing statics makes code hard to test and impossible to inject. Prefer instances and interfaces for anything with behaviour you may want to replace.

Composition versus inheritance

Inheritance means is-a (a is an ). Composition means has-a (a has an ). Prefer composition: it is more flexible, does not lock you into a hierarchy, and is easier to test because the parts can be replaced. Deep inheritance trees are brittle, because a change in the base class can break every derived class.

Practise

1. Remove from and read the compiler warning. Then make virtual and use .
2. Write an abstract class with an abstract method and two derived classes.
3. Take the Types, Strings and OOP quiz.