Understanding SOLID Violations in a Class (With Example and Solution)

Sudha Reddy — Sun, 27 Apr 2025 18:23:25 +0000

What issues do you see in the below code? Which SOLID principles are being violated, and how would you correct them?

public class Account
{
    public decimal balance { get; set; }
    public decimal CalculateInterest(string accountType)
    {
        decimal interest = 0;
        if (accountType.Equals("Regular"))
        {
            interest = balance * 0.4m;
            if (balance < 1000)
                interest -= balance * 0.2m;
            else if (balance < 50000)
                interest += balance * 0.4m;
        }
        else if (accountType.Equals("Salary"))
        {
            interest = balance * 0.5m;
        }
        return interest;
    }
}

Problems in the Code

• SRP Violated: Single Responsibility Principle
• OCP Violated: Open/Closed Principle
(Other SOLID principles are not applicable yet.)

Why is SRP Violated?
• Account class handles:
Balance data
Interest calculation logic
• Two reasons to change = SRP violation.
SRP says: A class should have only one reason to change.
Why is OCP Violated?
• Adding new account types (e.g., "Premium") needs modifying CalculateInterest.
• Risk of introducing bugs while changing old code.
OCP says:
• Open for extension
• Closed for modification

Correct Approach:

Using Polymorphism (Inheritance)
• Create an abstract base class Account.
• Subclasses like RegularAccount, SalaryAccount override CalculateInterest.
• Follows SRP and OCP.
Example:

public abstract class Account
{
    public decimal Balance { get; set; }
    public abstract decimal CalculateInterest();
}

public class RegularAccount : Account
{
    public override decimal CalculateInterest()
    {
        decimal interest = Balance * 0.4m;
        if (Balance < 1000)
            interest -= Balance * 0.2m;
        else if (Balance < 50000)
            interest += Balance * 0.4m;
        return interest;
    }
}

public class SalaryAccount : Account
{
    public override decimal CalculateInterest()
    {
        return Balance * 0.5m;
    }
}

using Strategy Pattern we can correct this code
• Create an IInterestCalculator interface.
• Create separate classes for each account type.
• Account class delegates calculation to the correct strategy.

public interface IInterestCalculator
{
    decimal CalculateInterest(decimal balance);
}

public class RegularAccountInterestCalculator : IInterestCalculator
{
    public decimal CalculateInterest(decimal balance)
    {
        decimal interest = balance * 0.4m;
        if (balance < 1000)
            interest -= balance * 0.2m;
        else if (balance < 50000)
            interest += balance * 0.4m;
        return interest;
    }
}

public class SalaryAccountInterestCalculator : IInterestCalculator
{
    public decimal CalculateInterest(decimal balance)
    {
        return balance * 0.5m;
    }
}

Modified Account Class

public class Account
{
    public decimal Balance { get; set; }
    private readonly IInterestCalculator _interestCalculator;

    public Account(IInterestCalculator interestCalculator)
    {
        _interestCalculator = interestCalculator;
    }

    public decimal CalculateInterest()
    {
        return _interestCalculator.CalculateInterest(Balance);
    }
}

Final Benefits
• SRP Achieved:
Account only manages balance.
Separate classes manage interest logic.
• OCP Achieved:
New account types? Just add a new class!
• Code is maintainable, testable, and professional.

Inheritance in C# – A Practical Guide with Example

Sudha Reddy — Sat, 26 Apr 2025 12:09:53 +0000

What is Inheritance?
In C#, inheritance allows a derived class to access the properties and methods of a base class. It enables code reuse, extension, and customization.

Key Concepts
•Single Inheritance: In C#, Multiple inheritance is not possible, a class can inherit only from one base class.
• Access Levels: Child classes can access public and protected members of the parent class.
• Method Overriding: Derived classes can override base class methods to change the base class method behaviour.
• Syntax: Use the : symbol to inherit from a base class.

Example: Account and SavingsAccount
Base Class

public class Account
{
    public string AccountNumber { get; set; }
    public double Balance { get; set; }
    public void Deposit(double amount)
    {
        Balance += amount;
        Console.WriteLine($"Deposited {amount}. New Balance: {Balance}");
    }
    public void Withdraw(double amount)
    {
        if (Balance >= amount)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrawn {amount}. Remaining Balance: {Balance}");
        }
        else
        {
            Console.WriteLine("Insufficient funds.");
        }
    }
}

Derived Class

public class SavingsAccount : Account
{
    public double InterestRate { get; set; }
    public void ApplyInterest()
    {
        double interest = Balance * InterestRate / 100;
        Balance += interest;
        Console.WriteLine($"Interest applied: {interest}. New Balance: {Balance}");
    }
}

Program Execution

class Program
{
    static void Main(string[] args)
    {
        SavingsAccount savings = new SavingsAccount();
        savings.AccountNumber = "SA12345";
        savings.Balance = 1000;
        savings.InterestRate = 5;

        savings.Deposit(500);
        savings.Withdraw(200);
        savings.ApplyInterest();
    }
}

Output
Deposited 500. New Balance: 1500
Withdrawn 200. Remaining Balance: 1300
Interest applied: 65. New Balance: 1365

Why To Use Inheritance?
• Code Reuse: Common operations like Deposit and Withdraw are defined once in Account.
• Extensibility: SavingsAccount adds new features (like interest calculation) without rewriting everything.
• Cleaner Architecture: Helps organize related classes in a logical structure.

Points to Remember
• Constructors are not inherited but can be called using base().
• Private members of a base class are not accessible in the derived class.
• You can override virtual methods to customize behaviour.
• Sealed classes cannot be inherited.

Advanced Example: Method Overriding
Suppose we want a specialized Withdraw behaviour for SavingsAccount:

public class Account
{
    public virtual void Withdraw(double amount)
    {
        Console.WriteLine($"Withdrawing {amount} from Account.");
    }
}

public class SavingsAccount : Account
{
    public override void Withdraw(double amount)
    {
        Console.WriteLine($"Withdrawing {amount} from SavingsAccount with extra checks.");
    }
}

Now, calling Withdraw() on a SavingsAccount will execute the overridden method.

Conclusion
Inheritance is a fundamental principle of Object-Oriented Programming in C#. By enabling the reuse and extension of base class functionality, it promotes the development of clean, maintainable, and scalable applications. A strong grasp of inheritance concepts significantly enhances your ability to design robust and efficient software within the .NET ecosystem.

DEV Community: Sudha Reddy

Understanding SOLID Violations in a Class (With Example and Solution)

Problems in the Code

Correct Approach:

Inheritance in C# – A Practical Guide with Example