LeetCode 4: Median of Two Sorted Arrays

LeetCode problem 4: Median of Two Sorted Arrays requires finding the median of two sorted arrays in O(log(m+n)) time complexity. This article will walk through the problem, analyze the approach, and provide a complete C# solution.

---

Problem Explanation

Given two sorted arrays, nums1 and nums2, find the median of the combined array. The solution must be efficient with a logarithmic time complexity.

---

What Is the Median?

The median is the middle value in a sorted list of numbers:

1. For an odd-length list, the median is the middle element.
2. For an even-length list, the median is the average of the two middle elements.

---

Example Walkthrough

Example 1:

Input:
nums1 = [1, 3]
nums2 = [2]

Output:
2.00000
Explanation:
Merged array: [1, 2, 3]. Median: 2.

---

Example 2:

Input:
nums1 = [1, 2]
nums2 = [3, 4]

Output:
2.50000
Explanation:
Merged array: [1, 2, 3, 4]. Median: (2 + 3) / 2 = 2.5.

---

Approach

To achieve O(log(m+n)) complexity, we can use binary search on the smaller array to partition the combined arrays. Here's the step-by-step approach:

1. Partition the Arrays

• Divide nums1 and nums2 into two halves such that all elements in the left half are less than or equal to those in the right half.

2. Use Binary Search

• Perform binary search on the smaller array (nums1 or nums2) to find the correct partition point.

3. Handle Odd and Even Cases

• If the combined length is odd, the median is the maximum of the left halves.
• If it's even, the median is the average of the maximum of the left halves and the minimum of the right halves.

---

C# Solution

Here’s the implementation:

using System;

public class Solution
{
    public double FindMedianSortedArrays(int[] nums1, int[] nums2)
    {
        // Ensure nums1 is the smaller array
        if (nums1.Length > nums2.Length)
        {
            return FindMedianSortedArrays(nums2, nums1);
        }

        int m = nums1.Length;
        int n = nums2.Length;
        int totalLeft = (m + n + 1) / 2;

        int left = 0, right = m;

        while (left <= right)
        {
            int partition1 = (left + right) / 2;
            int partition2 = totalLeft - partition1;

            int maxLeft1 = (partition1 == 0) ? int.MinValue : nums1[partition1 - 1];
            int minRight1 = (partition1 == m) ? int.MaxValue : nums1[partition1];

            int maxLeft2 = (partition2 == 0) ? int.MinValue : nums2[partition2 - 1];
            int minRight2 = (partition2 == n) ? int.MaxValue : nums2[partition2];

            if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1)
            {
                // Found the correct partition
                if ((m + n) % 2 == 0)
                {
                    return (Math.Max(maxLeft1, maxLeft2) + Math.Min(minRight1, minRight2)) / 2.0;
                }
                else
                {
                    return Math.Max(maxLeft1, maxLeft2);
                }
            }
            else if (maxLeft1 > minRight2)
            {
                // Move left
                right = partition1 - 1;
            }
            else
            {
                // Move right
                left = partition1 + 1;
            }
        }

        throw new ArgumentException("Input arrays are not valid.");
    }
}

---

How the Code Works

1. Ensure nums1 is the smaller array:

   • This minimizes the binary search range.

2. Binary Search to Find Partition:

   • Partition the smaller array and calculate the corresponding partition in the larger array.
   • Adjust the partition using binary search based on the comparisons of the left and right halves.

3. Calculate Median:

   • Use the maximum of the left halves and the minimum of the right halves to calculate the median.

---

Example Execution

Input:

int[] nums1 = { 1, 3 };
int[] nums2 = { 2 };

Execution:

1. Ensure nums1 is smaller.
2. Perform binary search to partition:
   • Partition 1: Left = [1], Right = [3]
   • Partition 2: Left = [2], Right = []
3. Median: max(1, 2) = 2.

Output:

2.00000

---

Complexity Analysis

• Time Complexity:
  O(log(min(m, n))) due to binary search.
• Space Complexity:
  O(1) as no extra space is used.

---

Comparison Table: Binary Search vs Brute Force

Approach	Time Complexity	Space Complexity	Notes
Binary Search	O(log(min(m,n)))	O(1)	Optimal for large arrays.
Merge and Find	O(m + n)	O(m + n)	Simpler but slower for large inputs.

LeetCode 2661: First Completely Painted Row or Column in C#

LeetCode problem 2661: First Completely Painted Row or Column asks us to determine the first operation at which a row or a column of a given matrix is fully painted. This is an interesting grid and mapping problem that requires efficient handling of operations due to the constraints.

In this article, we’ll break down the problem, analyze the approach, and provide a complete solution in C#.

---

Problem Explanation

You are given:

1. An array arr: Represents the order in which the cells in the matrix will be painted.
2. A matrix mat: A grid containing unique integers ranging from 1 to m * n.

The task is to determine the smallest index i in arr at which a row or column in mat becomes fully painted.

---

Constraints

1. Matrix dimensions: m x n, where 1 <= m, n <= 10^5.
2. Number of elements: 1 <= m * n <= 10^5.
3. Both arr and mat contain all integers from 1 to m * n, and all values are unique.

---

Approach

Given the constraints, we need an efficient solution. A direct approach that simulates painting the matrix would be too slow. Instead, we use a mapping and counting approach.

Key Steps:

1. Map Values to Coordinates:

   • Create a dictionary to map each value in mat to its corresponding (row, column).

2. Track Painted Rows and Columns:

   • Maintain two arrays: rowCount and colCount, to track how many cells in each row and column are painted.

3. Iterate Over arr:

   • For each value in arr, determine the corresponding row and column using the dictionary.
   • Increment the counters for the row and column.
   • Check if the row or column is fully painted.

4. Stop at First Complete:

   • Return the index of the first operation where a row or column becomes fully painted.

---

C# Solution

Here’s the full implementation:

using System;
using System.Collections.Generic;

public class Solution
{
    public int FirstCompleteIndex(int[] arr, int[][] mat)
    {
        int m = mat.Length;     // Number of rows
        int n = mat[0].Length;  // Number of columns
        
        // Step 1: Map matrix values to their coordinates
        var valueToCoordinates = new Dictionary<int, (int row, int col)>();
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                valueToCoordinates[mat[i][j]] = (i, j);
            }
        }
        
        // Step 2: Initialize row and column counters
        int[] rowCount = new int[m];
        int[] colCount = new int[n];
        
        // Step 3: Iterate through arr to paint cells
        for (int i = 0; i < arr.Length; i++)
        {
            int value = arr[i];
            var (row, col) = valueToCoordinates[value];

            // Increment the row and column counters
            rowCount[row]++;
            colCount[col]++;
            
            // Check if the row or column is fully painted
            if (rowCount[row] == n || colCount[col] == m)
            {
                return i;  // Return the 0-based index
            }
        }
        
        return -1;  // This should never happen given the problem constraints
    }
}

---

How the Solution Works

1. Mapping Values to Coordinates:

   • The dictionary valueToCoordinates allows us to quickly locate the (row, col) position of any value in O(1) time.

2. Counting Painted Cells:

   • The rowCount and colCount arrays are used to efficiently track how many cells in each row and column have been painted.

3. Stopping Early:

   • The solution stops as soon as a row or column is fully painted, ensuring optimal performance.

---

Example Walkthrough

Example 1:

Input:

int[] arr = {1, 3, 4, 2};
int[][] mat = {
    new int[] {1, 4},
    new int[] {2, 3}
};

Execution:

1. Map matrix values to coordinates:
   {1: (0, 0), 4: (0, 1), 2: (1, 0), 3: (1, 1)}.
2. Process arr:
   • Paint 1: rowCount = [1, 0], colCount = [1, 0]
   • Paint 3: rowCount = [1, 1], colCount = [1, 1]
   • Paint 4: rowCount = [2, 1], colCount = [1, 2] → Row 0 is fully painted.
3. Output: 2

---

Comparison Table

Feature	Relational Databases	NoSQL Databases
Input Size Handling	Up to 10^5 rows	Efficient for large datasets
Mapping Complexity	O(1) lookup	Same for key-value stores
Scalability	Limited	Horizontally scalable

---

Summary

This problem showcases how mapping and counting can simplify operations on matrices. By efficiently tracking painted cells, the solution avoids unnecessary computations and scales well with large inputs.

Try this approach to gain deeper insights into solving grid and matrix problems effectively!

Beyond the Pillars: Additional Concepts in OOP for C# Developers

Object-Oriented Programming (OOP) isn’t limited to the four main principles—encapsulation, inheritance, polymorphism, and abstraction. There are additional concepts that, when combined with the core principles, help build well-structured, maintainable, and reusable code. In this post, we'll cover composition, association, aggregation, cohesion, and coupling—key ideas that further enhance your OOP knowledge.

1. Composition: "Has-a" Relationship

Definition:
Composition is a design principle where one class contains an instance of another class. Instead of inheriting behavior, the object "has-a" relationship with another object.

Why It Matters:

• Promotes flexibility by enabling object reuse.
• Avoids the downsides of deep inheritance hierarchies.

C# Example:

public class Engine
{
    public void Start() => Console.WriteLine("Engine started.");
}

public class Car
{
    private readonly Engine engine = new Engine();  // Car "has-a" Engine.

    public void StartCar()
    {
        engine.Start();
        Console.WriteLine("Car is running.");
    }
}

// Usage
var car = new Car();
car.StartCar();  // Output: "Engine started." "Car is running."

2. Association: General Relationship Between Classes

Definition:
Association represents a general "uses" relationship between two classes where one class uses or interacts with another.

• Unidirectional Association: One class knows about the other (e.g., Doctor knows about Patient).
• Bidirectional Association: Both classes know about each other.

C# Example:

public class Doctor
{
    public string Name { get; set; }

    public void Treat(Patient patient)
    {
        Console.WriteLine($"{Name} is treating {patient.Name}.");
    }
}

public class Patient
{
    public string Name { get; set; }
}

// Usage
var doctor = new Doctor { Name = "Dr. Sarah" };
var patient = new Patient { Name = "John Doe" };
doctor.Treat(patient);  // Output: "Dr. Sarah is treating John Doe."

3. Aggregation: "Whole-Part" Relationship (Weak Ownership)

Definition:
Aggregation is a type of association where one class represents a "whole-part" relationship, but the parts can exist independently of the whole.

Why It Matters:

• Supports loose coupling between the container and its contained classes.

C# Example:

public class Team
{
    public List<Employee> Members { get; } = new List<Employee>();

    public void AddMember(Employee employee)
    {
        Members.Add(employee);
    }
}

public class Employee
{
    public string Name { get; set; }
}

// Usage
var team = new Team();
var employee = new Employee { Name = "Alice" };
team.AddMember(employee);  // The `Employee` exists independently of the `Team`.

In this example, the Employee can exist without being part of a Team.

4. Cohesion: Single Responsibility of a Class

Definition:
Cohesion measures how closely related the responsibilities of a class are. High cohesion means that the class performs a single, well-defined task.

Why It Matters:

• High cohesion improves code readability and maintainability.
• A cohesive class is easier to understand and debug.

Example:

public class InvoiceService
{
    public void GenerateInvoice()
    {
        Console.WriteLine("Generating invoice...");
    }

    public void EmailInvoice()
    {
        Console.WriteLine("Emailing invoice...");
    }
}

If you add unrelated methods (like database management) in this class, cohesion decreases. Instead, break responsibilities into different classes.

5. Coupling: Dependency Between Classes

Definition:
Coupling refers to the degree of dependency between classes.

• Tightly Coupled: Classes are strongly dependent on each other.
• Loosely Coupled: Classes can function independently of each other.

Why It Matters:

• Loose coupling improves flexibility and makes the code more adaptable to changes.
• Tight coupling makes the system harder to modify and maintain.

C# Example:

public class ReportGenerator
{
    private readonly IReportFormatter formatter;

    public ReportGenerator(IReportFormatter reportFormatter)
    {
        formatter = reportFormatter;  // Loose coupling via interface
    }

    public void Generate()
    {
        formatter.FormatReport();
        Console.WriteLine("Report generated.");
    }
}

public interface IReportFormatter
{
    void FormatReport();
}

public class PDFReportFormatter : IReportFormatter
{
    public void FormatReport() => Console.WriteLine("Formatting report as PDF...");
}

// Usage
var pdfFormatter = new PDFReportFormatter();
var generator = new ReportGenerator(pdfFormatter);
generator.Generate();  // Output: "Formatting report as PDF..." "Report generated."

By using an interface (IReportFormatter), the ReportGenerator class is loosely coupled to the formatter. You can easily swap out the implementation without changing the ReportGenerator class.

Conclusion

Understanding these additional OOP concepts helps you write better-structured, maintainable, and more reusable code. While the core principles of OOP lay the foundation, concepts like composition, association, aggregation, cohesion, and coupling further enrich your design approach.

Encapsulation vs Abstraction in C#: Key Differences and How They Complement Each Other

Object-Oriented Programming (OOP) principles aim to create clean, maintainable, and reusable code. Among these principles, Encapsulation and Abstraction are often discussed together due to their overlapping goals. However, they address different aspects of software design. In this post, we’ll clarify their differences, show how they complement each other, and provide examples in C#.

1. What is Encapsulation?

Encapsulation focuses on hiding data and providing controlled access through public methods or properties. It ensures that sensitive information is protected and only modified in well-defined ways.

Key Features:

• Access modifiers (private, public, protected) control visibility.
• Data is hidden inside the class, exposed only through getters and setters.
• Ensures that fields cannot be accessed directly from outside the class.

C# Example:

public class BankAccount
{
    private double balance;  // Private field

    public double Balance  // Public property with a getter
    {
        get { return balance; }
        private set
        {
            if (value >= 0) balance = value;
        }
    }

    public BankAccount(double initialBalance)
    {
        Balance = initialBalance;
    }

    public void Deposit(double amount)
    {
        if (amount > 0) Balance += amount;
    }
}

In this example:

• balance is hidden from direct modification.
• The Deposit method controls how deposits are made.

2. What is Abstraction?

Abstraction focuses on hiding implementation details and showing only the essential features of an object. In C#, this is done using abstract classes and interfaces.

Key Features:

• Defines what an object should do, not how it does it.
• Simplifies interaction with complex objects by hiding unnecessary details.
• Abstract classes can have both implemented and abstract methods, while interfaces provide pure abstractions.

C# Example:

public abstract class Shape
{
    public abstract void Draw();  // Abstract method (no implementation)
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

// Usage
Shape shape = new Circle();
shape.Draw();  // Output: "Drawing a circle."

In this example:

• Shape defines the essential feature Draw() without explaining how it works.
• Circle and Rectangle implement the details of how they "draw" themselves.

Key Differences Between Encapsulation and Abstraction

Feature	Encapsulation	Abstraction
Focus	Hides internal data and controls access.	Hides implementation details and shows essential features.
Purpose	Data protection and controlled access.	Simplifies object interactions and defines contracts.
Implementation	Achieved using access modifiers, properties, and methods.	Achieved using abstract classes and interfaces.
Example	Hiding a balance field and exposing a Deposit method.	Defining Draw() for different shapes without knowing how they draw.

How Encapsulation and Abstraction Complement Each Other

Encapsulation and Abstraction often work together:

• Encapsulation ensures that internal state changes happen through controlled interfaces.
• Abstraction ensures that users of an object only see what is necessary, without needing to know how it works internally.

For example:

• A bank account class hides the exact logic for calculating interest (encapsulation) while exposing methods like Deposit() and Withdraw() to users (abstraction).

Conclusion

Encapsulation and Abstraction are essential for building modular, secure, and maintainable systems. While encapsulation focuses on how data is accessed and modified, abstraction focuses on which essential features are exposed to the user. Together, they create a robust framework for object-oriented design.

Abstraction in C#: The Foundation of OOP

Abstraction is a fundamental principle of Object-Oriented Programming (OOP) that helps simplify complex systems by breaking them down into more manageable parts. In this post, we’ll explore what abstraction means, how it works in C#, and real-world examples that demonstrate its power.

What is Abstraction?

Abstraction is the process of hiding unnecessary details and showing only the essential features of an object. It allows developers to focus on what an object does, rather than how it does it.

In simple terms:

• Abstraction provides a simplified view by hiding implementation details.
• You use abstract classes or interfaces in C# to achieve abstraction.

For example, when you drive a car, you focus on pressing the accelerator, not how the engine handles fuel injection.

Why is Abstraction Important?

• Reduces Complexity: You don't need to understand all the implementation details to use an object.
• Improves Maintainability: Changes to internal implementation don’t affect external code.
• Encourages Modularity: Promotes a clean separation of responsibilities.
• Enforces Standards: Abstract classes and interfaces define consistent behavior across implementations.

Key Features of Abstraction

1. Abstract Classes: Can contain both abstract (method signatures) and non-abstract methods (concrete methods with implementation).
2. Interfaces: Only contain method signatures and properties (without implementation) and enforce that derived classes implement all members.
3. Access Modifiers: Control visibility and access to members, further supporting abstraction.

Example 1: Using Abstract Classes

Here’s an example of abstraction using an abstract class Shape:

// Abstract class
public abstract class Shape
{
    public abstract void Draw();  // Abstract method with no implementation

    public void DisplayInfo()  // Concrete method with implementation
    {
        Console.WriteLine("This is a shape.");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

// Usage
Shape shape1 = new Circle();
Shape shape2 = new Rectangle();
shape1.Draw();  // Output: "Drawing a circle."
shape2.Draw();  // Output: "Drawing a rectangle."

In this example:

• Shape is an abstract class with an abstract method Draw().
• Circle and Rectangle provide their own specific implementations of Draw().

Example 2: Using Interfaces

Now, let’s look at abstraction with an interface:

public interface IVehicle
{
    void Start();
    void Stop();
}

public class Car : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Car is starting...");
    }

    public void Stop()
    {
        Console.WriteLine("Car is stopping...");
    }
}

public class Motorcycle : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Motorcycle is starting...");
    }

    public void Stop()
    {
        Console.WriteLine("Motorcycle is stopping...");
    }
}

// Usage
IVehicle vehicle1 = new Car();
IVehicle vehicle2 = new Motorcycle();
vehicle1.Start();  // Output: "Car is starting..."
vehicle2.Stop();   // Output: "Motorcycle is stopping..."

In this example:

• The IVehicle interface defines the contract for Start() and Stop().
• Both Car and Motorcycle implement the interface, enforcing a consistent structure.

Benefits of Abstraction in C#

• Simplifies Development: Focus on the "what" without worrying about the "how."
• Improves Code Reusability: Define common behavior once and implement it across multiple classes.
• Flexible Architecture: Changes to internal implementations do not affect external code.
• Standardization: Interfaces and abstract classes enforce a consistent API.

When to Use Abstract Classes vs Interfaces

Feature	Abstract Class	Interface
Implementation	Can include method bodies.	Cannot include implementation (before C# 8.0).
Inheritance	Supports single inheritance.	Supports multiple inheritance.
Use Case	When sharing base functionality.	When defining a contract.

Common Mistakes to Avoid

1. Confusing Abstraction with Inheritance: Remember that abstraction focuses on "what" behavior, while inheritance is about reusing code.
2. Using Too Many Abstract Layers: Too much abstraction can make the code difficult to follow.
3. Inconsistent Naming: Ensure interface and abstract class names clearly indicate their purpose (e.g., IShape or BaseService).

Conclusion

Abstraction is a key principle of OOP that simplifies the way you interact with complex systems. By using abstract classes and interfaces, you can create a modular, maintainable, and reusable codebase that hides unnecessary details and exposes only what’s relevant.

In the next post, we’ll cover Encapsulation vs Abstraction—clarifying the differences between these two principles and how they complement each other.

Polymorphism in C#: The Foundation of OOP

Polymorphism is one of the most powerful features of Object-Oriented Programming (OOP). It allows objects to take on multiple forms, making your code more flexible, maintainable, and reusable. In this post, we’ll break down what polymorphism is, how it works, and practical examples in C#.

What is Polymorphism?

The word "polymorphism" comes from Greek, meaning "many forms." In C#, polymorphism allows you to use the same interface or base class to work with different derived types.

In simpler terms:

• You can use the same method or property across different objects.
• The actual implementation that runs depends on the type of object.

There are two main types of polymorphism:

1. Compile-Time (Static) Polymorphism: Achieved using method overloading.
2. Run-Time (Dynamic) Polymorphism: Achieved using method overriding.

Why is Polymorphism Important?

• Code Flexibility: You can write code that works with a base class or interface without knowing the exact type of object.
• Reduced Complexity: Handle different object types with the same code.
• Extensibility: Add new types or behaviors without changing existing code.

Key Features of Polymorphism

• Method Overloading: Same method name, different parameter lists.
• Method Overriding: Same method signature in the base and derived classes.
• Interfaces and Abstract Classes: Support polymorphism by enforcing a common structure.

Example 1: Method Overloading (Compile-Time Polymorphism)

In C#, you can define multiple methods with the same name but different signatures (i.e., parameter types or counts).

public class MathOperations
{
    // Add two integers
    public int Add(int a, int b)
    {
        return a + b;
    }

    // Add three integers
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }

    // Add two doubles
    public double Add(double a, double b)
    {
        return a + b;
    }
}

// Usage
var math = new MathOperations();
Console.WriteLine(math.Add(3, 4));          // Output: 7
Console.WriteLine(math.Add(3, 4, 5));       // Output: 12
Console.WriteLine(math.Add(3.5, 4.5));      // Output: 8.0

In this example:

• The Add method is overloaded to handle different numbers and types of inputs.
• The compiler decides which Add method to call based on the parameters.

Example 2: Method Overriding (Run-Time Polymorphism)

Run-time polymorphism occurs when a derived class provides its own implementation of a base class method.

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("The dog barks.");
    }
}

public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("The cat meows.");
    }
}

// Usage
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.Speak();  // Output: "The dog barks."
animal2.Speak();  // Output: "The cat meows."

Here’s what’s happening:

• The Animal class has a virtual method Speak().
• Dog and Cat override Speak() with their own implementations.
• The same Speak() method call behaves differently based on the object type (this is the magic of polymorphism!).

Polymorphism with Interfaces

Interfaces also support polymorphism by allowing different classes to implement the same interface.

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

// Usage
IShape shape1 = new Circle();
IShape shape2 = new Rectangle();
shape1.Draw();  // Output: "Drawing a circle."
shape2.Draw();  // Output: "Drawing a rectangle."

Benefits of Polymorphism in C#

• Consistency: Use the same interface for different objects.
• Reusability: Write more generic code that can handle future types.
• Simplified Code: No need for multiple if-else or switch statements to check object types.

Common Mistakes to Avoid

1. Not Marking Methods as virtual or override: Without these keywords, method overriding won’t work.
2. Excessive Use of Polymorphism: Overusing polymorphism can make your code harder to read if not documented well.

Conclusion

Polymorphism is a game-changer in OOP, allowing you to write more flexible and maintainable code. Whether you're overloading methods for compile-time flexibility or overriding methods for runtime adaptability, polymorphism makes your programs more powerful and easier to extend.

In the next post, we'll cover Abstraction—another key OOP principle that helps you focus on "what" an object does, not "how" it does it.

Inheritance in C#: The Foundation of OOP

Inheritance is one of the fundamental principles of Object-Oriented Programming (OOP) that helps developers write DRY (Don't Repeat Yourself) code by enabling class reuse. In this post, we'll dive into what inheritance is, its key benefits, and practical examples in C# to show how it works.

What is Inheritance?

Inheritance allows one class (called the derived or child class) to inherit the properties and methods of another class (called the base or parent class). The derived class can also add its own unique behavior.

In simpler terms:

• Base Class: The class that provides reusable functionality.
• Derived Class: The class that inherits and extends the base class.

In C#, inheritance is achieved using the : symbol:

class DerivedClass : BaseClass

Why is Inheritance Important?

• Code Reusability: Write once, reuse multiple times by inheriting shared code.
• Extensibility: Add or override functionality in derived classes.
• Simplified Maintenance: Common functionality is centralized in one place.
• Polymorphism: Enables treating objects of derived classes as objects of the base class (more on this in the next post!).

Key Features of Inheritance

1. Access Modifiers: Control which members of the base class are accessible in the derived class.
2. base Keyword: Allows access to base class constructors or methods.
3. Overriding Methods: Derived classes can change base class behavior using virtual, override, and sealed keywords.

Example 1: Animal and Dog Class

Let’s start with a simple example showing how a Dog class can inherit from an Animal class.

// Base class
public class Animal
{
    public string Name { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

// Derived class
public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} is barking.");
    }
}

// Usage
var dog = new Dog { Name = "Buddy" };
dog.Eat();  // Inherited from Animal class
dog.Bark(); // Specific to Dog class

In this example:

• The Dog class inherits the Eat() method and Name property from the Animal class.
• It also introduces a new method Bark().

Example 2: Overriding Methods

You can also override base class methods to provide specific behavior in the derived class.

public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape...");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle!");
    }
}

// Usage
Shape shape = new Circle();
shape.Draw();  // Output: "Drawing a circle!"

Here’s what’s happening:

• Shape has a virtual Draw() method.
• Circle overrides Draw() to provide its own specific implementation.
• When you call Draw() on a Circle object, the overridden method is executed.

Benefits of Inheritance in C#

• Avoids Redundancy: Reduces the need to copy and paste common code.
• Extensibility: Easily add features to an existing base class without rewriting everything.
• Simplifies Relationships: Express "is-a" relationships (e.g., a Dog is an Animal).
• Supports Polymorphism: Makes it easier to write flexible and dynamic code.

Things to Watch Out For

1. Tightly Coupled Code: Be cautious—too much inheritance can make your code harder to modify.
2. Avoid Deep Hierarchies: Prefer composition over inheritance when possible to prevent overly complex class trees.

Conclusion

Inheritance is a powerful tool that can make your C# projects more organized and efficient when used correctly. By creating base classes and inheriting from them, you can avoid code duplication and create an intuitive structure that reflects real-world relationships.

In the next post, we’ll cover Polymorphism—the secret sauce of OOP that makes your code flexible and reusable in new ways.