Program.cs

/*Bank Account System that demonstrates:

Polymorphism (base class + derived classes overriding behavior)

SRP (Single Responsibility Principle) — each class has a clear, single purpose

OCP (Open/Closed Principle) — system is open for extension (e.g. new account types), closed for modification

LSP (Liskov Substitution Principle) — derived account types can be used wherever a base account is expected

Sealed Logger — cannot be inherited



using System;

// SRP: This class represents a generic bank account.
public abstract class BankAccount
{
    public string AccountNumber { get; }
    public string HolderName { get; }
    public decimal Balance { get; protected set; }

    protected BankAccount(string accountNumber, string holderName, decimal initialBalance)
    {
        AccountNumber = accountNumber;
        HolderName = holderName;
        Balance = initialBalance;
    }

    public virtual void Deposit(decimal amount)
    {
        if (amount <= 0)
        {
            TransactionLogger.Instance.Log("Deposit failed: Invalid amount.");
            return;
        }
        Balance += amount;
        TransactionLogger.Instance.Log($"Deposited {amount:C} to {AccountNumber}. New balance: {Balance:C}");
    }

    public abstract void Withdraw(decimal amount);

    public override string ToString() => $"{HolderName} - {AccountNumber} - Balance: {Balance:C}";
}

// OCP + LSP: SavingsAccount extends BankAccount, can replace it anywhere.
public class SavingsAccount : BankAccount
{
    private const decimal WithdrawalLimit = 1000m;

    public SavingsAccount(string accountNumber, string holderName, decimal initialBalance)
        : base(accountNumber, holderName, initialBalance) { }

    public override void Withdraw(decimal amount)
    {
        if (amount <= 0 || amount > Balance)
        {
            TransactionLogger.Instance.Log("Savings withdrawal failed: Invalid amount.");
            return;
        }

        if (amount > WithdrawalLimit)
        {
            TransactionLogger.Instance.Log($"Savings withdrawal failed: Amount exceeds limit of {WithdrawalLimit:C}.");
            return;
        }

        Balance -= amount;
        TransactionLogger.Instance.Log($"Withdrew {amount:C} from savings account {AccountNumber}. New balance: {Balance:C}");
    }
}

// OCP + LSP: CurrentAccount adds overdraft capability.
public class CurrentAccount : BankAccount
{
    private const decimal OverdraftLimit = 500m;

    public CurrentAccount(string accountNumber, string holderName, decimal initialBalance)
        : base(accountNumber, holderName, initialBalance) { }

    public override void Withdraw(decimal amount)
    {
        if (amount <= 0)
        {
            TransactionLogger.Instance.Log("Current withdrawal failed: Invalid amount.");
            return;
        }

        if (Balance - amount < -OverdraftLimit)
        {
            TransactionLogger.Instance.Log("Current withdrawal failed: Exceeds overdraft limit.");
            return;
        }

        Balance -= amount;
        TransactionLogger.Instance.Log($"Withdrew {amount:C} from current account {AccountNumber}. New balance: {Balance:C}");
    }
}

// SRP + sealed (cannot be inherited): handles logging only.
public sealed class TransactionLogger
{
    private static readonly TransactionLogger _instance = new TransactionLogger();

    private TransactionLogger() { }

    public static TransactionLogger Instance => _instance;

    public void Log(string message)
    {
        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {message}");
    }
}

// Demonstration
public class Program
{
    public static void Main()
    {
        BankAccount savings = new SavingsAccount("SA001", "Alice", 2000m);
        BankAccount current = new CurrentAccount("CA001", "Bob", 500m);

        savings.Deposit(300);
        savings.Withdraw(1200);  // exceeds limit
        savings.Withdraw(800);

        current.Deposit(200);
        current.Withdraw(900);   // allowed with overdraft
        current.Withdraw(900);   // exceeds overdraft

        Console.WriteLine();
        Console.WriteLine(savings);
        Console.WriteLine(current);
    }
}


/*
| Principle                       | How It’s Applied                                                                                         |
| ------------------------------- | -------------------------------------------------------------------------------------------------------- |
| **SRP (Single Responsibility)** | Each class has one responsibility — `BankAccount` manages balances, `TransactionLogger` handles logging. |
| **OCP (Open/Closed)**           | You can add new account types (e.g. `BusinessAccount`) without modifying existing classes.               |
| **LSP (Liskov Substitution)**   | `SavingsAccount` and `CurrentAccount` can both be used as `BankAccount` without breaking functionality.  |
| **Polymorphism**                | The `Withdraw()` method is overridden in derived classes for specific behavior.                          |
| **Sealed Class**                | `TransactionLogger` is sealed to prevent extension and ensure consistent logging behavior.               |


/*
E-Commerce Discount Engine, showing abstraction, polymorphism, and OCP (Open/Closed Principle).
*/

/*

using System;

// Base abstract class: defines a common contract for all discounts
public abstract class Discount
{
    // Method to calculate final price after applying discount
    public abstract decimal ApplyDiscount(decimal originalPrice);
}

// Derived class: percentage-based discount (e.g. 10%)
public class PercentageDiscount : Discount
{
    private readonly decimal _percentage;

    public PercentageDiscount(decimal percentage)
    {
        _percentage = percentage;
    }

    public override decimal ApplyDiscount(decimal originalPrice)
    {
        if (_percentage < 0 || _percentage > 100)
        {
            Console.WriteLine("Invalid percentage discount.");
            return originalPrice;
        }

        decimal discountAmount = originalPrice * (_percentage / 100m);
        return originalPrice - discountAmount;
    }
}

// Derived class: fixed amount discount (e.g. $20 off)
public class FixedDiscount : Discount
{
    private readonly decimal _amount;

    public FixedDiscount(decimal amount)
    {
        _amount = amount;
    }

    public override decimal ApplyDiscount(decimal originalPrice)
    {
        if (_amount < 0)
        {
            Console.WriteLine("Invalid fixed discount amount.");
            return originalPrice;
        }

        decimal finalPrice = originalPrice - _amount;
        return finalPrice < 0 ? 0 : finalPrice;
    }
}

// Sealed class: represents no discount (cannot be inherited)
public sealed class NoDiscount : Discount
{
    public override decimal ApplyDiscount(decimal originalPrice)
    {
        return originalPrice; // no changes
    }
}

// Demonstration
public class Program
{
    public static void Main()
    {
        Discount percentage = new PercentageDiscount(10m);
        Discount fixedDiscount = new FixedDiscount(25m);
        Discount none = new NoDiscount();

        decimal price = 200m;

        Console.WriteLine($"Original Price: {price:C}");
        Console.WriteLine($"After 10% Discount: {percentage.ApplyDiscount(price):C}");
        Console.WriteLine($"After $25 Discount: {fixedDiscount.ApplyDiscount(price):C}");
        Console.WriteLine($"After No Discount: {none.ApplyDiscount(price):C}");

        // OCP: Adding a new discount type without modifying existing code
        Discount bogo = new BuyOneGetOneDiscount();
        Console.WriteLine($"After BOGO Discount: {bogo.ApplyDiscount(price):C}");
    }
}

// Demonstrating Open/Closed Principle
// You can extend behavior by adding new discount types like this:
public class BuyOneGetOneDiscount : Discount
{
    public override decimal ApplyDiscount(decimal originalPrice)
    {
        // For demo: half price when BOGO applies
        return originalPrice / 2;
    }
}


*/

/*Singleton Logger implemented in clean, production-ready C# following SOLID and thread-safe best practices*/
/*


using System;

public sealed class Logger
{
    // Step 1: Create a private static readonly instance (eager initialization)
    private static readonly Logger _instance = new Logger();

    // Step 2: Private constructor prevents external instantiation
    private Logger()
    {
        Console.WriteLine("Logger initialized.");
    }

    // Step 3: Public static property to access the single instance
    public static Logger Instance
    {
        get { return _instance; }
    }

    // Step 4: Add a simple logging method
    public void Log(string message)
    {
        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {message}");
    }
}

// Demonstration
public class Program
{
    public static void Main()
    {
        Logger logger1 = Logger.Instance;
        logger1.Log("Application started.");

        Logger logger2 = Logger.Instance;
        logger2.Log("Performing a database operation...");

        // Both references point to the same instance
        Console.WriteLine(Object.ReferenceEquals(logger1, logger2)
            ? "Same instance confirmed ✅"
            : "Different instances ❌");
    }
}

/*


/*Polymorphism in Shapes, implemented in clean, SOLID-friendly C# showing abstraction, inheritance, and polymorphism in action.*/


/*

using System;

// Base abstract class: Shape
public abstract class Shape
{
    public abstract double Area(); // Abstract method forces subclasses to implement
}

// Derived class: Circle
public class Circle : Shape
{
    public double Radius { get; }

    public Circle(double radius)
    {
        Radius = radius;
    }

    public override double Area()
    {
        return Math.PI * Radius * Radius;
    }
}

// Derived class: Rectangle
public class Rectangle : Shape
{
    public double Width { get; }
    public double Height { get; }

    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

    public override double Area()
    {
        return Width * Height;
    }
}

// Derived class: Triangle
public class Triangle : Shape
{
    public double BaseLength { get; }
    public double Height { get; }

    public Triangle(double baseLength, double height)
    {
        BaseLength = baseLength;
        Height = height;
    }

    public override double Area()
    {
        return 0.5 * BaseLength * Height;
    }
}

// Static class to demonstrate polymorphism — calls Area() on any shape
public static class ShapePrinter
{
    public static void PrintArea(Shape shape)
    {
        Console.WriteLine($"{shape.GetType().Name} Area: {shape.Area():F2}");
    }
}

// Demonstration
public class Program
{
    public static void Main()
    {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        Shape triangle = new Triangle(3, 8);

        ShapePrinter.PrintArea(circle);
        ShapePrinter.PrintArea(rectangle);
        ShapePrinter.PrintArea(triangle);
    }
}

*/




/* Mini ETL Framework, built to demonstrate abstraction, inheritance, polymorphism, sealed classes, and a static counter tracking how many ETL runs have executed. */

/* 

using System;
using System.Collections.Generic;

// Abstract base class — defines the ETL framework
public abstract class ETLProcessor
{
    // Static counter to track total runs across all processors
    private static int _runCount = 0;

    // Template Method — defines the workflow
    public void Run()
    {
        Console.WriteLine($"\n[{GetType().Name}] Starting ETL Process...");
        Extract();
        Transform();
        Load();
        _runCount++;
        Console.WriteLine($"[{GetType().Name}] ETL Process Completed. Total Runs: {_runCount}\n");
    }

    // Abstract methods for derived classes to implement
    protected abstract void Extract();
    protected abstract void Transform();
    protected abstract void Load();
}

// CSV Implementation
public class CsvETLProcessor : ETLProcessor
{
    private List<string> _data = new List<string>();

    protected override void Extract()
    {
        Console.WriteLine("Extracting data from CSV file...");
        _data = new List<string> { "Alice,24", "Bob,30", "Charlie,28" };
    }

    protected override void Transform()
    {
        Console.WriteLine("Transforming CSV data (splitting names and ages)...");
        _data = _data.ConvertAll(d => d.Replace(",", " - Age: "));
    }

    protected override void Load()
    {
        Console.WriteLine("Loading CSV data into database...");
        _data.ForEach(Console.WriteLine);
    }
}

// JSON Implementation
public class JsonETLProcessor : ETLProcessor
{
    private List<Dictionary<string, object>> _data = new List<Dictionary<string, object>>();

    protected override void Extract()
    {
        Console.WriteLine("Extracting data from JSON...");
        _data = new List<Dictionary<string, object>> {
            new() { {"name", "Diana"}, {"age", 26} },
            new() { {"name", "Ethan"}, {"age", 32} }
        };
    }

    protected override void Transform()
    {
        Console.WriteLine("Transforming JSON data (incrementing age by 1)...");
        _data.ForEach(record => record["age"] = (int)record["age"] + 1);
    }

    protected override void Load()
    {
        Console.WriteLine("Loading JSON data into data warehouse...");
        foreach (var record in _data)
            Console.WriteLine($"{record["name"]} - Age: {record["age"]}");
    }
}

// Sealed Excel Implementation (cannot be inherited)
public sealed class ExcelETLProcessor : ETLProcessor
{
    private List<string> _rows = new List<string>();

    protected override void Extract()
    {
        Console.WriteLine("Extracting data from Excel sheet...");
        _rows = new List<string> { "ProductA,100", "ProductB,150" };
    }

    protected override void Transform()
    {
        Console.WriteLine("Transforming Excel data (converting to key-value format)...");
        _rows = _rows.ConvertAll(r => $"Item: {r.Split(',')[0]}, Quantity: {r.Split(',')[1]}");
    }

    protected override void Load()
    {
        Console.WriteLine("Loading Excel data into reporting system...");
        _rows.ForEach(Console.WriteLine);
    }
}

// Demonstration
public class Program
{
    public static void Main()
    {
        ETLProcessor csvProcessor = new CsvETLProcessor();
        ETLProcessor jsonProcessor = new JsonETLProcessor();
        ETLProcessor excelProcessor = new ExcelETLProcessor();

        csvProcessor.Run();
        jsonProcessor.Run();
        excelProcessor.Run();
    }
}

*/