Challenge 2: Method Hiding via new — Possible Solution
====================================================================

Program.cs:

class Shape
{
    public double Area() => 0;   // NOT virtual
}

class Circle : Shape
{
    public double Radius;
    public Circle(double radius) { Radius = radius; }
    public new double Area() => Math.PI * Radius * Radius;   // hides, doesn't override
}

Shape s = new Circle(3);
Circle c = new Circle(3);

Console.WriteLine(s.Area());   // through the Shape-typed reference
Console.WriteLine(c.Area());   // through the Circle-typed reference

Output:

    0
    28.274333882308138

Explanation:
Because Shape.Area() is not virtual and Circle.Area() uses new instead
of override, there is no dynamic dispatch happening at all -- this is
method hiding. Which Area() runs is decided by the DECLARED
(compile-time) type of the reference used to call it, not the
object's real runtime type. Both `s` and `c` point to the exact same
underlying Circle object, yet s.Area() returns Shape's own 0 (because
`s` is declared as Shape), while c.Area() returns Circle's real
calculation (because `c` is declared as Circle) -- the opposite of
Challenge 1's result, and the opposite of what java1-5's Java would
ever produce.

WHY THIS WORKS AS AN ANSWER
------------------------------
This reproduces the exact method-hiding scenario the chapter
describes, using the identical underlying object accessed through two
differently-typed references to show the declared-type-dependent
result the chapter's own warn-box calls out as easy to miss.