Base class and derived class in C Sharp (C#) - Deep Dive

Overview - Base class and derived class

What is it?

A base class is like a blueprint that defines common features and behaviors. A derived class is a new blueprint that builds on the base class, adding or changing features. This lets programmers reuse code and organize related things neatly. Think of it as a family tree where children inherit traits from parents.

Why it matters

Without base and derived classes, programmers would repeat the same code many times, making programs bigger and harder to fix. This concept saves time and reduces mistakes by sharing common parts. It also helps organize complex programs so they are easier to understand and change later.

Where it fits

Before learning this, you should know what classes and objects are in C#. After this, you can learn about interfaces, polymorphism, and advanced object-oriented design patterns.

Mental Model

Core Idea

A derived class inherits properties and behaviors from a base class, allowing code reuse and extension.

Think of it like...

Imagine a car factory blueprint (base class) that defines a basic car. A sports car blueprint (derived class) uses the basic car blueprint but adds a turbo engine and special paint. The sports car inherits all basic car features but adds its own unique parts.

Base Class
┌───────────────┐
│   Vehicle     │
│ - wheels      │
│ - color       │
│ + Drive()     │
└─────┬─────────┘
      │
      ▼
Derived Class
┌───────────────┐
│   Car         │
│ + PlayRadio() │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Objects

Concept: Learn what classes and objects are in C# as the building blocks for inheritance.

A class is a template that describes what an object can have (fields) and do (methods). An object is an instance of a class. For example, a class 'Animal' might have a field 'name' and a method 'Speak()'. You create an object like 'dog' from the 'Animal' class.

Result

You can create objects that hold data and perform actions defined by their class.

Knowing classes and objects is essential because inheritance builds on these concepts to share and extend behavior.

2

Foundation

Defining a Base Class

Concept: Create a base class that holds common properties and methods for other classes to use.

In C#, a base class is defined with fields and methods that describe shared features. For example: class Animal { public string Name; public void Speak() { Console.WriteLine("Animal speaks"); } } This class can be used directly or extended by other classes.

Result

You have a reusable template that other classes can build upon.

A base class centralizes common code, reducing duplication and making maintenance easier.

3

Intermediate

Creating a Derived Class

🤔Before reading on: do you think a derived class can use base class methods without rewriting them? Commit to your answer.

Concept: A derived class inherits all members of the base class and can add new members or override existing ones.

In C#, use a colon to inherit: class Dog : Animal { public void Bark() { Console.WriteLine("Woof!"); } } The 'Dog' class has 'Name' and 'Speak()' from 'Animal' plus its own 'Bark()' method.

Result

Derived class objects can use base class features and their own new features.

Inheritance lets you extend functionality without rewriting code, making programs more flexible.

4

Intermediate

Using Base Class Members in Derived Class

🤔Before reading on: do you think a derived class can change how a base class method works? Commit to your answer.

Concept: Derived classes can override base class methods to change behavior or call base methods to reuse code.

Use the 'virtual' keyword in base class and 'override' in derived class: class Animal { public virtual void Speak() { Console.WriteLine("Animal speaks"); } } class Dog : Animal { public override void Speak() { Console.WriteLine("Dog barks"); } } This changes how 'Speak()' works for 'Dog'.

Result

Derived classes customize inherited behavior while keeping a shared interface.

Overriding allows specific behavior per class, enabling polymorphism and better design.

5

Intermediate

Access Modifiers and Inheritance

Concept: Learn how 'public', 'protected', and 'private' control what derived classes can see and use.

'Public' members are accessible everywhere. 'Protected' members are accessible only in the base and derived classes. 'Private' members are hidden from derived classes. Example: class Animal { private int age; protected string name; public void ShowName() { Console.WriteLine(name); } } Derived classes can use 'name' but not 'age'.

Result

You control what parts of a class are shared or hidden to protect data and design.

Understanding access modifiers prevents accidental misuse and enforces good encapsulation.

6

Advanced

Constructor Behavior in Inheritance

🤔Before reading on: do you think the base class constructor runs automatically when creating a derived class object? Commit to your answer.

Concept: When creating a derived class object, the base class constructor runs first to initialize base parts.

Example: class Animal { public Animal() { Console.WriteLine("Animal created"); } } class Dog : Animal { public Dog() { Console.WriteLine("Dog created"); } } Creating 'new Dog()' prints: Animal created Dog created

Result

Base class initialization happens before derived class setup, ensuring proper object state.

Knowing constructor order helps avoid bugs with uninitialized base parts and supports clean design.

7

Expert

Hidden Members and New Keyword

🤔Before reading on: do you think a derived class member with the same name as a base class member replaces it or hides it? Commit to your answer.

Concept: Derived classes can hide base class members using the 'new' keyword, creating separate versions instead of overriding.

Example: class Animal { public void Speak() { Console.WriteLine("Animal speaks"); } } class Dog : Animal { public new void Speak() { Console.WriteLine("Dog barks differently"); } } Calling 'Speak()' on a Dog object uses the new method, but casting to Animal calls the base method.

Result

You can create different behaviors without polymorphism, but it can confuse which method runs.

Understanding hiding vs overriding prevents subtle bugs and clarifies method dispatch in complex hierarchies.

Under the Hood

At runtime, a derived class object contains the base class data and methods as part of its memory layout. Method calls use a table (vtable) to find the right function, allowing overridden methods to replace base ones dynamically. Constructors run in order from base to derived to ensure proper setup.

Why designed this way?

This design supports code reuse and flexibility while keeping performance efficient. Early object-oriented languages separated inheritance and polymorphism, but C# combines them with clear rules to avoid ambiguity and maintain type safety.

Object Creation Flow
┌───────────────┐
│ Base Class    │
│ Constructor   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Derived Class │
│ Constructor   │
└──────┬────────┘
       │
       ▼
┌───────────────────────────┐
│ Object with base + derived │
│ data and methods           │
└───────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a derived class copy the base class code into itself? Commit to yes or no.

Common Belief: Derived classes copy all the base class code inside them.

Reality: Derived classes do not copy code; they reference base class members and share the same code in memory.

Why it matters: Thinking code is copied leads to confusion about memory use and can cause inefficient designs or misunderstandings about updates.

Quick: Can private members of a base class be accessed directly by derived classes? Commit to yes or no.

Common Belief: Derived classes can access all base class members, including private ones.

Reality: Private members are hidden from derived classes; only public and protected members are accessible.

Why it matters: Assuming private members are accessible can cause compilation errors and security issues.

Quick: Does using the 'new' keyword in a derived class override the base method? Commit to yes or no.

Common Belief: 'new' keyword overrides base class methods like 'override' does.

Reality: 'new' hides the base method but does not override it; method calls depend on the reference type.

Why it matters: Misunderstanding this causes bugs where the wrong method runs, especially when using base class references.

Quick: Is inheritance the only way to reuse code in C#? Commit to yes or no.

Common Belief: Inheritance is the only way to share code between classes.

Reality: Composition and interfaces are alternative ways to reuse code and design flexible systems.

Why it matters: Overusing inheritance can lead to rigid, hard-to-maintain code; knowing alternatives improves design choices.

Expert Zone

1

Overriding methods require the base method to be marked 'virtual' or 'abstract'; otherwise, 'override' is not allowed.

2

Constructors are not inherited; derived classes must call base constructors explicitly or implicitly to initialize base parts.

3

Using 'sealed' on a class or method prevents further inheritance or overriding, controlling extension points.

When NOT to use

Avoid inheritance when classes do not share a true 'is-a' relationship. Prefer composition or interfaces to build flexible and maintainable designs.

Production Patterns

In real-world C# projects, base classes often define common behavior for UI controls, data models, or services. Derived classes customize or extend these behaviors. Patterns like Template Method rely on base classes defining steps with derived classes filling details.

Connections

Interfaces

Interfaces define contracts without implementation, while base classes provide shared code and state.

Understanding base and derived classes clarifies when to use inheritance versus interfaces for flexible design.

Composition over Inheritance

Composition builds complex objects by combining simpler ones, offering an alternative to inheritance.

Knowing inheritance limits helps appreciate composition as a way to avoid rigid class hierarchies.

Biology - Genetic Inheritance

Inheritance in programming mirrors biological inheritance where offspring inherit traits from parents.

Seeing inheritance as passing traits helps grasp why derived classes share and extend base class features naturally.

Common Pitfalls

#1 Trying to access private base class members directly in derived class.

Wrong approach:

class Animal {
private int age;
}
class Dog : Animal {
void ShowAge() {
Console.WriteLine(age); // Error: 'age' is inaccessible
}
}

Correct approach:

class Animal {
private int age;
protected int GetAge() { return age; }
}
class Dog : Animal {
void ShowAge() {
Console.WriteLine(GetAge()); // Correct access
}
}

Root cause:

Misunderstanding access modifiers and visibility rules.

#2 Using 'new' keyword thinking it overrides base method polymorphically.

Wrong approach:

class Animal {
public void Speak() { Console.WriteLine("Animal"); }
}
class Dog : Animal {
public new void Speak() { Console.WriteLine("Dog"); }
}
Animal a = new Dog();
a.Speak(); // Prints 'Animal', not 'Dog'

Correct approach:

class Animal {
public virtual void Speak() { Console.WriteLine("Animal"); }
}
class Dog : Animal {
public override void Speak() { Console.WriteLine("Dog"); }
}
Animal a = new Dog();
a.Speak(); // Prints 'Dog'

Root cause:

Confusing method hiding with overriding and polymorphism.

#3 Not calling base class constructor in derived class leading to uninitialized base state.

Wrong approach:

class Animal {
public Animal() { Console.WriteLine("Animal created"); }
}
class Dog : Animal {
public Dog() { Console.WriteLine("Dog created"); }
}
// Dog constructor does not explicitly call base constructor

Correct approach:

class Dog : Animal {
public Dog() : base() { Console.WriteLine("Dog created"); }
}
// Base constructor runs automatically or explicitly

Root cause:

Not understanding constructor chaining and initialization order.

Key Takeaways

Base classes define common features and behaviors that derived classes inherit and extend.

Derived classes reuse base class code, reducing duplication and improving organization.

Access modifiers control what derived classes can see and use from base classes.

Overriding methods allows derived classes to customize behavior while preserving interfaces.

Understanding constructor order and method hiding prevents subtle bugs in inheritance hierarchies.