How often do you use inheritance in your projects?

I use inheritance moderately. It is useful for implementing the Don't Repeat Yourself (DRY) principle and creating type hierarchies, but excessive use can lead to tight coupling and testing issues. I prefer composition or interfaces when possible.

Examples of using inheritance:

• Implementation of the template method.
• Creating base classes for handling common logical blocks, for example, in UI components or command handlers.

// Base class for data processing
public abstract class DataProcessor
{
    public void ProcessData()
    {
        LoadData();
        TransformData();
        SaveData();
    }

    protected abstract void LoadData();
    protected abstract void TransformData();
    protected abstract void SaveData();
}

// Concrete class inheriting from the base
public class CsvDataProcessor : DataProcessor
{
    protected override void LoadData()
    {
        // Logic for loading from CSV
    }

    protected override void TransformData()
    {
        // Logic for transforming CSV
    }

    protected override void SaveData()
    {
        // Logic for saving to CSV
    }
}

I avoid inheritance when it creates a "diamond" problem or when the subclass does not truly represent an "is-a" relationship to the base class (Liskov Substitution Principle). Instead, I use interfaces to define contracts and composition to assemble functionality from smaller, independent objects.