Abstract Classes in C# — Compile-Time Contract Enforcement

using System;

// Abstract class — cannot be instantiated with 'new PaymentProcessor()'.
// Models the shared skeleton of every payment processor in the system.
abstract class PaymentProcessor
{
    // Concrete field — shared state every processor needs.
    // Protected so subclasses can read it; private to external callers.
    protected string processorName;

    // Constructor — abstract classes CAN and SHOULD have constructors
    // to initialise shared state. Subclasses invoke this via : base(...).
    // The constructor itself is never called directly from outside.
    protected PaymentProcessor(string name)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("Processor name cannot be empty.", nameof(name));
        processorName = name;
    }

    // ABSTRACT method — no body. Every concrete subclass MUST implement this.
    // The compiler refuses to build any subclass that omits it.
    // There is no sensible default for 'how to process a payment' at this level.
    public abstract bool ProcessPayment(decimal amount);

    // ABSTRACT method — every processor validates differently.
    // Card processors check Luhn numbers; PayPal checks account status.
    public abstract bool ValidatePaymentDetails();

    // CONCRETE method — shared logic every processor reuses as-is.
    // Receipt formatting is identical regardless of payment method.
    public void PrintReceipt(decimal amount)
    {
        Console.WriteLine($"[{processorName}] Receipt: ${amount:F2} processed successfully.");
    }

    // CONCRETE method — shared audit logging every processor must emit.
    protected void LogTransaction(decimal amount, bool success)
    {
        string status = success ? "SUCCESS" : "FAILED";
        Console.WriteLine($"[AUDIT] {processorName} | Amount: ${amount:F2} | Status: {status}");
    }
}

// Concrete class — MUST implement every abstract member or the build breaks.
// CS0534 fires at compile time with the exact missing method name.
class CreditCardProcessor : PaymentProcessor
{
    private readonly string cardLastFour;

    public CreditCardProcessor(string cardLastFour)
        : base("Credit Card")  // Calls the abstract class constructor
    {
        this.cardLastFour = cardLastFour;
    }

    public override bool ValidatePaymentDetails()
    {
        // Real implementation: Luhn algorithm check, expiry validation etc.
        bool isValid = !string.IsNullOrWhiteSpace(cardLastFour) && cardLastFour.Length == 4;
        Console.WriteLine($"Validating card ending in {cardLastFour}: {(isValid ? "Valid" : "Invalid")}");
        return isValid;
    }

    public override bool ProcessPayment(decimal amount)
    {
        if (!ValidatePaymentDetails()) return false;
        Console.WriteLine($"Charging ${amount:F2} to card ending {cardLastFour} via Stripe gateway...");
        LogTransaction(amount, true);
        PrintReceipt(amount);
        return true;
    }
}

class PayPalProcessor : PaymentProcessor
{
    private readonly string accountEmail;

    public PayPalProcessor(string email) : base("PayPal")
    {
        accountEmail = email;
    }

    public override bool ValidatePaymentDetails()
    {
        bool isValid = accountEmail.Contains('@');
        Console.WriteLine($"Validating PayPal account {accountEmail}: {(isValid ? "Valid" : "Invalid")}");
        return isValid;
    }

    public override bool ProcessPayment(decimal amount)
    {
        if (!ValidatePaymentDetails()) return false;
        Console.WriteLine($"Redirecting ${amount:F2} to PayPal checkout for {accountEmail}...");
        LogTransaction(amount, true);
        PrintReceipt(amount);
        return true;
    }
}

class Program
{
    static void Main()
    {
        // PaymentProcessor p = new PaymentProcessor(); -- CS0144: cannot instantiate abstract type.

        // Polymorphism in action — same variable type, completely different behaviour.
        PaymentProcessor[] processors =
        {
            new CreditCardProcessor("4242"),
            new PayPalProcessor("user@example.com")
        };

        foreach (PaymentProcessor processor in processors)
        {
            Console.WriteLine("---");
            processor.ProcessPayment(49.99m);
            Console.WriteLine();
        }
    }
}

using System;

// Abstract base — owns the ALGORITHM (the fixed pipeline sequence).
// Subclasses own the STEPS (the domain-specific implementations).
abstract class ReportGenerator
{
    // Abstract property — forces each subclass to declare its own report title.
    // No backing field here. The subclass decides: hardcoded, config-driven, or computed.
    public abstract string ReportTitle { get; }

    // Abstract property — forces each subclass to declare its destination.
    public abstract string OutputDestination { get; }

    // TEMPLATE METHOD — this is the algorithm skeleton.
    // It is concrete and NOT virtual — the pipeline sequence must never change.
    // Marking it sealed in subclasses prevents accidental override further down.
    public void GenerateReport()
    {
        Console.WriteLine($"=== Starting: {ReportTitle} ===");
        Console.WriteLine($"    Destination: {OutputDestination}");

        FetchData();       // Step 1 — abstract, must be provided by subclass
        ValidateData();    // Step 2 — abstract, must be provided by subclass
        FormatData();      // Step 3 — abstract, must be provided by subclass
        RenderOutput();    // Step 4 — abstract, must be provided by subclass

        LogCompletion();   // Step 5 — concrete shared logic, runs for every report

        Console.WriteLine($"=== Complete: {ReportTitle} ===\n");
    }

    // Abstract steps — each subclass provides its own domain-specific implementation.
    // Protected because they are implementation details, not public API surface.
    protected abstract void FetchData();
    protected abstract void ValidateData();
    protected abstract void FormatData();
    protected abstract void RenderOutput();

    // CONCRETE method — shared infrastructure every report type needs.
    // Subclasses inherit this without writing a single line.
    private void LogCompletion()
    {
        Console.WriteLine($"  [LOG] {ReportTitle} pipeline completed at {DateTime.UtcNow:HH:mm:ss} UTC.");
    }
}

class SalesReport : ReportGenerator
{
    // Computed property — title is derived from the report type, not stored.
    public override string ReportTitle => "Monthly Sales Summary";
    public override string OutputDestination => "finance-team@company.com";

    protected override void FetchData()
        => Console.WriteLine("  [Sales] Querying orders table from SQL Server (last 30 days)...");

    protected override void ValidateData()
        => Console.WriteLine("  [Sales] Asserting no null revenue rows and positive unit counts...");

    protected override void FormatData()
        => Console.WriteLine("  [Sales] Aggregating totals by region, product category, and rep...");

    protected override void RenderOutput()
        => Console.WriteLine("  [Sales] Rendering to .xlsx with pivot tables and conditional formatting.");
}

class SecurityAuditReport : ReportGenerator
{
    public override string ReportTitle => "Weekly Security Audit Log";
    public override string OutputDestination => "compliance@company.com (encrypted)";

    protected override void FetchData()
        => Console.WriteLine("  [Audit] Streaming from distributed CloudWatch event log...");

    protected override void ValidateData()
        => Console.WriteLine("  [Audit] Checking for gaps in event sequence and tamper indicators...");

    protected override void FormatData()
        => Console.WriteLine("  [Audit] Filtering to WARN/ERROR/CRITICAL severity only...");

    protected override void RenderOutput()
        => Console.WriteLine("  [Audit] Encrypting PDF and attaching digital signature for compliance.");
}

class Program
{
    static void Main()
    {
        // Different types — same pipeline entry point.
        // The abstract base guarantees the order. Subclasses guarantee the content.
        ReportGenerator[] scheduledReports =
        {
            new SalesReport(),
            new SecurityAuditReport()
        };

        foreach (ReportGenerator report in scheduledReports)
        {
            report.GenerateReport();
        }
    }
}

using System;
using System.Collections.Generic;

// INTERFACE — defines a capability.
// Any type can be ITaxable regardless of family or hierarchy.
// No shared state, no constructors, pure contract.
interface ITaxable
{
    decimal CalculateTax(decimal baseAmount);
    string TaxJurisdiction { get; }
}

// ABSTRACT CLASS — defines a family.
// All products share a name, price, category, and pricing formula.
// Shared logic lives here. Unique logic is abstract.
abstract class Product : ITaxable
{
    // Shared fields — every product has these.
    public string ProductName { get; }
    public decimal BasePrice { get; }
    public string Category { get; }

    // Constructor — initialises shared state for every product.
    // Subclasses call this via : base(...). The base validates common rules.
    protected Product(string name, decimal price, string category)
    {
        if (price <= 0) throw new ArgumentException("Price must be positive.", nameof(price));
        ProductName = name;
        BasePrice = price;
        Category = category;
    }

    // ABSTRACT — every product type calculates its own category discount differently.
    // Electronics get percentage discounts; groceries get fixed promotional amounts.
    public abstract decimal GetDiscount();

    // ABSTRACT — ITaxable contract, but the implementation varies by product type.
    // Some products are VAT-exempt; others attract import duties on top of VAT.
    public abstract decimal CalculateTax(decimal baseAmount);

    // ABSTRACT property from ITaxable — subclass declares its tax jurisdiction.
    public abstract string TaxJurisdiction { get; }

    // CONCRETE — the final price formula is identical for every product.
    // We own this method in the abstract class so it can never drift.
    public decimal GetFinalPrice()
    {
        decimal afterDiscount = BasePrice - GetDiscount();
        decimal tax = CalculateTax(afterDiscount);
        return afterDiscount + tax;
    }

    public override string ToString()
        => $"{ProductName,-25} Base: ${BasePrice,7:F2} | "
         + $"Discount: -${GetDiscount(),5:F2} | "
         + $"Tax ({TaxJurisdiction}): ${CalculateTax(BasePrice - GetDiscount()),6:F2} | "
         + $"Final: ${GetFinalPrice(),7:F2}";
}

class ElectronicProduct : Product
{
    public ElectronicProduct(string name, decimal price)
        : base(name, price, "Electronics") { }

    // 10% loyalty discount on all electronics.
    public override decimal GetDiscount() => BasePrice * 0.10m;

    // 20% VAT — standard UK rate.
    public override decimal CalculateTax(decimal baseAmount) => baseAmount * 0.20m;

    public override string TaxJurisdiction => "UK VAT 20%";
}

class GroceryProduct : Product
{
    public GroceryProduct(string name, decimal price)
        : base(name, price, "Grocery") { }

    // Fixed £2 promotional discount.
    public override decimal GetDiscount() => 2.00m;

    // Most groceries are VAT-zero rated in the UK.
    public override decimal CalculateTax(decimal baseAmount) => 0.00m;

    public override string TaxJurisdiction => "UK VAT 0% (Zero-rated)";
}

class Program
{
    static void Main()
    {
        var inventory = new List<Product>
        {
            new ElectronicProduct("Wireless Headphones", 120.00m),
            new ElectronicProduct("USB-C Docking Station", 89.99m),
            new GroceryProduct("Organic Coffee Beans", 18.50m),
            new GroceryProduct("Sourdough Bread", 4.75m)
        };

        Console.WriteLine("=== Product Pricing Summary ===");
        foreach (Product item in inventory)
            Console.WriteLine(item);

        // The abstract class satisfies the ITaxable interface — so this works.
        // Any code that expects ITaxable can receive any Product subtype.
        Console.WriteLine("\n=== ITaxable Interface Polymorphism ===");
        ITaxable taxableItem = new ElectronicProduct("Smart Watch", 249.99m);
        Console.WriteLine($"Smart Watch tax ({taxableItem.TaxJurisdiction}): "
            + $"${taxableItem.CalculateTax(249.99m):F2}");
    }
}