Inheritance & Interfaces

var rex = new Dog("Rex", "beagle");
Console.WriteLine(rex.Describe());
rex.Eat();
rex.Fetch();

Animal a = rex;                  // a Dog IS an Animal
Console.WriteLine(a.Name);

class Animal
{
    public string Name { get; }
    protected int Meals;         // visible to derived classes, not to callers

    public Animal(string name) => Name = name;

    public void Eat()
    {
        Meals++;
        Console.WriteLine($"{Name} eats (meal {Meals})");
    }

    public string Describe() => $"{Name} the {GetType().Name}";
}

class Dog : Animal
{
    public string Breed { get; }

    public Dog(string name, string breed) : base(name)   // run Animal's constructor first
    {
        Breed = breed;
    }

    public void Fetch() => Console.WriteLine($"{Name} the {Breed} fetches after {Meals} meal(s)");
}

var shapes = new List<Shape> { new Circle(1), new Square(2), new Shape() };
foreach (Shape s in shapes)
    Console.WriteLine($"{s.Name}: {s.Area():0.00}");

class Shape
{
    public virtual string Name => "shape";
    public virtual double Area() => 0;
}

class Circle(double r) : Shape
{
    public override string Name => "circle";
    public override double Area() => Math.PI * r * r;
}

class Square(double side) : Shape
{
    public override string Name => $"square ({base.Name} with 4 equal sides)";
    public override double Area() => side * side;
}

var jobs = new List<Report> { new SalesReport(), new StockReport() };
foreach (var job in jobs)
    Console.WriteLine(job.Render());

abstract class Report
{
    // the template: fixed order, specific steps left to subclasses
    public string Render() => $"== {Title} ==\n{Body()}\n-- {Footer} --";

    protected abstract string Title { get; }
    protected abstract string Body();
    protected virtual string Footer => "end";      // optional to override
}

class SalesReport : Report
{
    protected override string Title => "Sales";
    protected override string Body() => "total: 1,200";
}

sealed class StockReport : Report
{
    protected override string Title => "Stock";
    protected override string Body() => "items: 37";
    protected override string Footer => "checked";
}

var items = new List<object> { new Photo("beach.jpg", 2400), new Invoice(99.5m) };

foreach (var item in items)
{
    if (item is IPrintable p) Console.WriteLine(p.Print());
    if (item is ISized s) Console.WriteLine($"  size: {s.Describe()}");
}

interface IPrintable
{
    string Print();
}

interface ISized
{
    long Bytes { get; }
    // default interface method: implementers get it for free
    string Describe() => Bytes >= 1024 ? $"{Bytes / 1024} KB" : $"{Bytes} B";
}

class Photo(string file, long bytes) : IPrintable, ISized   // two interfaces
{
    public long Bytes => bytes;
    public string Print() => $"[photo {file}]";
}

class Invoice(decimal total) : IPrintable
{
    public string Print() => $"[invoice {total:0.00}]";
}

var doc = new Document();
Console.WriteLine(((IEnglish)doc).Title);
Console.WriteLine(((IFrench)doc).Title);

IFrench fr = doc;
Console.WriteLine(fr.Title);

interface IEnglish { string Title { get; } }
interface IFrench { string Title { get; } }

class Document : IEnglish, IFrench
{
    string IEnglish.Title => "User guide";
    string IFrench.Title => "Guide de l'utilisateur";
}

object[] things = { 42, "hello", 3.5, new Dog("Rex"), null!, new List<int> { 1, 2 } };

foreach (object? t in things)
    Console.WriteLine(Describe(t));

static string Describe(object? o) => o switch
{
    null => "nothing",
    int n when n > 40 => $"a big int {n}",
    int n => $"an int {n}",
    string { Length: > 3 } s => $"a long string \"{s}\"",
    Dog d => $"a dog called {d.Name}",
    IEnumerable<int> seq => $"ints summing to {seq.Sum()}",
    _ => $"something else: {o.GetType().Name}",
};

record Dog(string Name);

Animal pet = new Cat();

Dog? maybeDog = pet as Dog;                 // no exception, just null
Console.WriteLine(maybeDog is null ? "not a dog" : "a dog");

if (pet is Cat cat)
    Console.WriteLine($"cat says {cat.Meow()}");

if (pet is not Dog)
    Console.WriteLine("definitely not a dog");

class Animal { }
class Dog : Animal { }
class Cat : Animal { public string Meow() => "meow"; }

var checkout = new Checkout(new List<IDiscount>
{
    new PercentOff(10),
    new FixedOff(5m),
    new BuyOver(100m, 15m),
});

Console.WriteLine(checkout.Total(80m));
Console.WriteLine(checkout.Total(200m));

interface IDiscount
{
    decimal Apply(decimal price);
}

class PercentOff(int percent) : IDiscount
{
    public decimal Apply(decimal price) => price * (100 - percent) / 100;
}

class FixedOff(decimal amount) : IDiscount
{
    public decimal Apply(decimal price) => Math.Max(0, price - amount);
}

class BuyOver(decimal threshold, decimal amount) : IDiscount
{
    public decimal Apply(decimal price) => price >= threshold ? price - amount : price;
}

class Checkout(List<IDiscount> discounts)
{
    // knows nothing about the concrete discount types
    public decimal Total(decimal price)
    {
        foreach (var d in discounts) price = d.Apply(price);
        return price;
    }
}

var cheap = new Car("city car", new PetrolEngine(), new BasicStereo());
var fancy = new Car("tourer", new ElectricMotor(), new PremiumStereo());

cheap.Drive();
fancy.Drive();

interface IEngine { string Start(); }
interface IStereo { string Play(); }

class PetrolEngine : IEngine { public string Start() => "vroom"; }
class ElectricMotor : IEngine { public string Start() => "hum"; }
class BasicStereo : IStereo { public string Play() => "radio"; }
class PremiumStereo : IStereo { public string Play() => "surround sound"; }

// Car HAS an engine and a stereo; it does not inherit from either
class Car(string model, IEngine engine, IStereo stereo)
{
    public void Drive() =>
        Console.WriteLine($"{model}: {engine.Start()}, playing {stereo.Play()}");
}