Polymorphism in C# — Method Hiding Broke Payment Fees

using System;

public class AuditLogger
{
    // Overload 1: Simple message log
    public void Log(string message)
    {
        Console.WriteLine($"[INFO] {DateTime.Now:HH:mm:ss} — {message}");
    }

    // Overload 2: Message with a severity level — same name, different signature
    public void Log(string message, string severity)
    {
        Console.WriteLine($"[{severity.ToUpper()}] {DateTime.Now:HH:mm:ss} — {message}");
    }

    // Overload 3: Log an exception directly — compiler picks this when an Exception is passed
    public void Log(Exception exception)
    {
        Console.WriteLine($"[ERROR] {DateTime.Now:HH:mm:ss} — {exception.GetType().Name}: {exception.Message}");
    }
}

class Program
{
    static void Main()
    {
        var logger = new AuditLogger();

        // Compiler resolves this to Overload 1
        logger.Log("User login successful");

        // Compiler resolves this to Overload 2
        logger.Log("Disk space below 10%", "warning");

        // Compiler resolves this to Overload 3
        logger.Log(new InvalidOperationException("Payment gateway timed out"));
    }
}

using System;
using System.Collections.Generic;

// Abstract base — there's no such thing as a generic 'payment', so we make it abstract
public abstract class PaymentMethod
{
    public string AccountReference { get; }

    protected PaymentMethod(string accountReference)
    {
        AccountReference = accountReference;
    }

    // Abstract method — every payment type MUST implement this
    public abstract decimal CalculateProcessingFee(decimal orderTotal);

    // Virtual method — has a sensible default, but subclasses CAN override it
    public virtual string GetReceiptLabel()
    {
        return $"Payment via {GetType().Name} (ref: {AccountReference})";
    }

    // Non-virtual — this behaviour never changes regardless of payment type
    public void PrintReceipt(decimal orderTotal)
    {
        decimal fee = CalculateProcessingFee(orderTotal);  // polymorphic call
        Console.WriteLine(GetReceiptLabel());               // polymorphic call
        Console.WriteLine($"  Order total : £{orderTotal:F2}");
        Console.WriteLine($"  Processing  : £{fee:F2}");
        Console.WriteLine($"  Grand total : £{orderTotal + fee:F2}");
        Console.WriteLine();
    }
}

public class CreditCardPayment : PaymentMethod
{
    private readonly bool _isPremiumCard;

    public CreditCardPayment(string cardReference, bool isPremiumCard)
        : base(cardReference)
    {
        _isPremiumCard = isPremiumCard;
    }

    // Credit cards charge 1.5% — 0.8% for premium cards
    public override decimal CalculateProcessingFee(decimal orderTotal)
    {
        decimal rate = _isPremiumCard ? 0.008m : 0.015m;
        return Math.Round(orderTotal * rate, 2);
    }

    public override string GetReceiptLabel()
    {
        string tier = _isPremiumCard ? "Premium" : "Standard";
        return $"{tier} Credit Card (ref: {AccountReference})";
    }
}

public class BankTransferPayment : PaymentMethod
{
    public BankTransferPayment(string sortCodeRef) : base(sortCodeRef) { }

    // Bank transfers are flat fee — not percentage-based
    public override decimal CalculateProcessingFee(decimal orderTotal)
    {
        return 0.25m;  // flat 25p regardless of order size
    }
    // Note: GetReceiptLabel() is NOT overridden — it uses the base default
}

public class CryptoPayment : PaymentMethod
{
    private readonly string _networkName;

    public CryptoPayment(string walletRef, string networkName) : base(walletRef)
    {
        _networkName = networkName;
    }

    // Crypto fees vary by network congestion — simulated here as 2%
    public override decimal CalculateProcessingFee(decimal orderTotal)
    {
        return Math.Round(orderTotal * 0.02m, 2);
    }

    public override string GetReceiptLabel()
    {
        return $"Crypto ({_networkName}) — wallet: {AccountReference}";
    }
}

class Program
{
    static void Main()
    {
        // The list holds the BASE TYPE — we don't care which concrete type is inside
        var checkoutPayments = new List<PaymentMethod>
        {
            new CreditCardPayment("VISA-4242", isPremiumCard: false),
            new CreditCardPayment("AMEX-0001", isPremiumCard: true),
            new BankTransferPayment("20-44-53"),
            new CryptoPayment("0xA1B2C3", "Ethereum")
        };

        decimal orderTotal = 150.00m;

        // Same call — PrintReceipt — but each payment type does its own thing
        foreach (PaymentMethod payment in checkoutPayments)
        {
            payment.PrintReceipt(orderTotal);
        }
    }
}

using System;
using System.Collections.Generic;

// The contract — any type that implements this becomes 'exportable'
public interface IReportExporter
{
    string FormatName { get; }
    void Export(IEnumerable<string> reportRows, string destinationPath);

    // C# 8+ default interface method — provides fallback without breaking old implementors
    void PrintExportSummary(string destinationPath)
    {
        Console.WriteLine($"  [{FormatName}] Export complete → {destinationPath}");
    }
}

public class PdfExporter : IReportExporter
{
    public string FormatName => "PDF";

    public void Export(IEnumerable<string> reportRows, string destinationPath)
    {
        Console.WriteLine($"Generating PDF with {System.Linq.Enumerable.Count(reportRows)} rows...");
        // Real implementation would use a PDF library like iTextSharp
        PrintExportSummary(destinationPath);
    }
}

public class CsvExporter : IReportExporter
{
    public string FormatName => "CSV";
    private readonly char _delimiter;

    public CsvExporter(char delimiter = ',')
    {
        _delimiter = delimiter;
    }

    public void Export(IEnumerable<string> reportRows, string destinationPath)
    {
        Console.WriteLine($"Writing CSV (delimiter: '{_delimiter}') with {System.Linq.Enumerable.Count(reportRows)} rows...");
        PrintExportSummary(destinationPath);
    }
}

public class JsonExporter : IReportExporter
{
    public string FormatName => "JSON";

    public void Export(IEnumerable<string> reportRows, string destinationPath)
    {
        Console.WriteLine($"Serialising {System.Linq.Enumerable.Count(reportRows)} rows to JSON...");
        // Overrides the default summary to add JSON-specific detail
        Console.WriteLine($"  [JSON] Minified export → {destinationPath}");
    }

    // Override the default interface method with a custom version
    public void PrintExportSummary(string destinationPath)
    {
        Console.WriteLine($"  [JSON] Minified export → {destinationPath}");
    }
}

// This class only knows about IReportExporter — it's completely decoupled from PDF/CSV/JSON
public class ReportingService
{
    private readonly IReportExporter _exporter;  // depends on the interface, not the concrete type

    // The concrete exporter is injected — swap it without touching this class
    public ReportingService(IReportExporter exporter)
    {
        _exporter = exporter;
    }

    public void RunMonthlyReport()
    {
        var salesData = new List<string>
        {
            "January,North,£42,500",
            "January,South,£31,200",
            "January,East,£28,900"
        };

        Console.WriteLine($"Running monthly report using: {_exporter.FormatName}");
        _exporter.Export(salesData, "/reports/monthly-2024-01");
        Console.WriteLine();
    }
}

class Program
{
    static void Main()
    {
        // Swap the exporter — ReportingService never needs to change
        var services = new List<ReportingService>
        {
            new ReportingService(new PdfExporter()),
            new ReportingService(new CsvExporter(delimiter: ';')),
            new ReportingService(new JsonExporter())
        };

        foreach (var service in services)
        {
            service.RunMonthlyReport();
        }
    }
}

using System;

public class Notification
{
    // NOT marked virtual — this is the problem
    public string GetDeliveryChannel()
    {
        return "Base: Generic channel";
    }

    // This one IS virtual — safe for polymorphism
    public virtual string GetMessagePreview()
    {
        return "Base: Default message preview";
    }
}

public class PushNotification : Notification
{
    // 'new' hides the base method — does NOT participate in polymorphism
    public new string GetDeliveryChannel()
    {
        return "Derived: Push via APNs/FCM";
    }

    // 'override' replaces the base method — true polymorphism
    public override string GetMessagePreview()
    {
        return "Derived: Push preview — tap to open";
    }
}

class Program
{
    static void Main()
    {
        PushNotification pushDirect = new PushNotification();
        Notification pushedAsBase = new PushNotification();  // same object, base type reference

        Console.WriteLine("=== Called on derived type directly ===");
        Console.WriteLine(pushDirect.GetDeliveryChannel());  // calls the 'new' hidden method
        Console.WriteLine(pushDirect.GetMessagePreview());   // calls the overridden method

        Console.WriteLine();
        Console.WriteLine("=== Called through base type reference ===");
        // GetDeliveryChannel: hiding — base type reference calls BASE version, ignores 'new'
        Console.WriteLine(pushedAsBase.GetDeliveryChannel());
        // GetMessagePreview: override — base type reference still calls DERIVED version
        Console.WriteLine(pushedAsBase.GetMessagePreview());
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

// The contract — open for extension
public interface IDiscountStrategy
{
    decimal CalculateDiscount(Order order);
    bool IsApplicable(Order order);
}

public class Order
{
    public decimal Total { get; set; }
    public string CustomerTier { get; set; }  // "Standard", "Gold", "Platinum"
    public bool IsHolidaySeason { get; set; }
    public int ItemsCount { get; set; }
}

public class NoDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order) => 0m;
    public bool IsApplicable(Order order) => false;  // fallback
}

public class LoyaltyDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order)
    {
        return order.CustomerTier switch
        {
            "Gold" => order.Total * 0.10m,
            "Platinum" => order.Total * 0.15m,
            _ => 0m
        };
    }

    public bool IsApplicable(Order order) => order.CustomerTier != "Standard";
}

public class SeasonalDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order)
    {
        return order.Total * 0.05m;
    }

    public bool IsApplicable(Order order) => order.IsHolidaySeason;
}

public class BulkDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order)
    {
        var discountPerItem = 0.5m; // 50p per item over 10
        var eligibleItems = Math.Max(order.ItemsCount - 10, 0);
        return eligibleItems * discountPerItem;
    }

    public bool IsApplicable(Order order) => order.ItemsCount > 10;
}

// The engine — closed for modification
public class DiscountEngine
{
    private readonly IEnumerable<IDiscountStrategy> _strategies;

    public DiscountEngine(IEnumerable<IDiscountStrategy> strategies)
    {
        _strategies = strategies;
    }

    public decimal CalculateTotalDiscount(Order order)
    {
        // No need to change this method when new discounts are added
        return _strategies
            .Where(s => s.IsApplicable(order))
            .Sum(s => s.CalculateDiscount(order));
    }
}

class Program
{
    static void Main()
    {
        var order = new Order
        {
            Total = 200.00m,
            CustomerTier = "Gold",
            IsHolidaySeason = true,
            ItemsCount = 15
        };

        // In production, these would be registered via DI
        var strategies = new List<IDiscountStrategy>
        {
            new NoDiscount(),
            new LoyaltyDiscount(),
            new SeasonalDiscount(),
            new BulkDiscount()
        };

        var engine = new DiscountEngine(strategies);
        var discount = engine.CalculateTotalDiscount(order);

        Console.WriteLine($"Order total: £{order.Total}");
        Console.WriteLine($"Total discount: £{discount:F2}");
        Console.WriteLine($"Final amount: £{order.Total - discount:F2}");
    }
}

// io.thecodeforge
var shapes = new List<Shape> { new Circle(), new Triangle() };

// Compiles — covariance via IEnumerable<out T>
IEnumerable<Shape> readOnly = shapes.Cast<Shape>();
foreach (var shape in readOnly)
    shape.Draw(); // Runtime calls Circle.Draw(), Triangle.Draw()

// Fails at compile-time — List<T> is invariant
// List<Shape> baseList = new List<Circle>(); // CS0266

// Safe pattern: declare with concrete type
var circles = new List<Circle> { new Circle(), new Circle() };
// Then convert only for read operations
IEnumerable<Shape> asShapes = circles;

// io.thecodeforge
public class PaymentProcessor
{
    public virtual bool Authorize(decimal amount)
    {
        // Base logic: log transaction
        Console.WriteLine($"Authorizing {amount:C}");
        return amount <= 10000;
    }
}

public sealed class SecurePaymentProcessor : PaymentProcessor
{
    public sealed override bool Authorize(decimal amount)
    {
        // Add audit, fraud check
        Console.WriteLine($"Secure check for {amount:C}");
        return base.Authorize(amount) && amount <= 5000;
    }
}

// Attempt to override sealed method — compile error
// public class HackedProcessor : SecurePaymentProcessor
// {
//     public override bool Authorize(decimal amount) { return true; } // CS0239
// }

// io.thecodeforge
public class EmailSender
{
    public void Send(string message) => 
        Console.WriteLine($"Email: {message}");
}

public class SmsSender
{
    public void Send(string message) => 
        Console.WriteLine($"SMS: {message}");
}

dynamic sender = GetSender("email"); // returns EmailSender or SmsSender at runtime

// Duck typing — no compile-time check
sender.Send("Alert!");

// Safe approach: wrap in try/catch
try { sender.Send("Alert!"); }
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex)
{
    Console.WriteLine($"Routing failed: {ex.Message}");
}

static object GetSender(string type) =>
    type == "email" ? new EmailSender() : new SmsSender();

public static decimal CalculateFee(Payment payment) => payment switch
{
    CreditCardPayment c => c.Amount * 0.02m,
    PayPalPayment p => p.Amount * 0.03m + 0.30m,
    BankTransfer b => 0.50m,
    _ => throw new ArgumentException("Unknown payment type")
};

dynamic payment = GetPayment();
decimal fee = payment.CalculateFee();
Console.WriteLine($"Fee: {fee}");

public static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
{
    T total = T.Zero;
    foreach (var v in values)
        total += v;
    return total;
}

// Usage:
var intSum = Sum(new[] { 1, 2, 3 });
var decimalSum = Sum(new[] { 1.5m, 2.3m });