By the end of this session, you will be able to:

• Explain and apply both forms of polymorphism
• Define and use abstract classes
• Define and implement interfaces
• Choose between an abstract class and an interface for a given design problem

• Compile-time — method overloading. The compiler selects which method to call based on the argument types at compile time. You covered this in Session 04.
• Runtime — method overriding with virtual / override. The runtime selects which implementation to execute based on the object's actual type. Covered in Session 05.
• Both forms let you write code that works on many types through a single unified interface
• Runtime polymorphism is the more powerful form — it enables collections of mixed types to be processed uniformly

Shape[] shapes = { new Circle(5), new Rectangle(3, 4) };

foreach (Shape s in shapes)
{
    Console.WriteLine(s.Area());   // correct override called at runtime
}

// The variable type is Shape, but the actual object decides which Area() runs

The array holds Shape references — but each call to Area() dispatches to the override in the actual concrete type.

• Marked with the abstract keyword — the compiler prevents direct instantiation
• Can contain abstract methods: declared with no body; every non-abstract derived class must provide an implementation
• Can also contain concrete methods: fully implemented, shared by all derived classes without repetition
• Can have constructors, fields, and properties — just like a normal class
• Models an IS-A relationship where the base type is genuinely incomplete on its own

public abstract class Notification
{
    public string Recipient { get; set; }
    public string Message   { get; set; }

    public Notification(string recipient, string message)
    {
        Recipient = recipient;
        Message   = message;
    }

    // No body — derived classes must provide this
    public abstract void Send();

    // Shared logic — available to all derived classes
    public void Log()
    {
        Console.WriteLine($"[LOG] Sending to {Recipient}: {Message}");
    }
}

public class EmailNotification : Notification
{
    public EmailNotification(string recipient, string message)
        : base(recipient, message) { }

    public override void Send()
        => Console.WriteLine($"Email to {Recipient}: {Message}");
}

public class SmsNotification : Notification
{
    public SmsNotification(string recipient, string message)
        : base(recipient, message) { }

    public override void Send()
        => Console.WriteLine($"SMS to {Recipient}: {Message}");
}

Both classes must implement Send() — the compiler enforces it. They inherit Log() for free.

List<Notification> queue = new List<Notification>
{
    new EmailNotification("alice@example.com", "Welcome!"),
    new SmsNotification("+1234567890", "Your code: 9876")
};

foreach (var n in queue)
{
    n.Log();    // concrete — shared method runs for both
    n.Send();   // abstract — polymorphic dispatch to the correct override
}

The list type is Notification. The runtime dispatches Send() to the correct subclass — the loop does not need to know which.

• Declared with the interface keyword; by convention the name starts with I
• Contains only member signatures — no fields, no constructors, no instance state (by default)
• A class that implements an interface must provide all declared members
• A class can implement multiple interfaces — overcoming C#'s single-inheritance limit
• The caller works through the interface type and never depends on the concrete class

static void Checkout(IPaymentProcessor processor, decimal amount)
{
    processor.ProcessPayment(amount);
}

// The caller decides which implementation to inject
Checkout(new StripeProcessor(), 99.99m);
Checkout(new PayPalProcessor(), 49.50m);

Checkout depends only on the contract, never on StripeProcessor or PayPalProcessor directly. Swapping providers requires no change to the method.

• IS-A relationship with shared state? Use an abstract class. All Animal subclasses share a Name field and a base constructor — that shared identity and data belongs in an abstract class.
• CAN-DO capability across unrelated types? Use an interface. Both a Dog and a Car can implement ISerializable — they have nothing in common except the capability.
• When in doubt: prefer an interface. It imposes no inheritance hierarchy and leaves the implementing class free to inherit from something else.

public class FileWriter : IDisposable
{
    private StreamWriter _writer;

    public FileWriter(string path)
        => _writer = new StreamWriter(path);

    public void Write(string text)
        => _writer.WriteLine(text);

    public void Dispose() => _writer?.Dispose();
}

// The 'using' statement calls Dispose() automatically at the closing brace
using (var writer = new FileWriter("log.txt"))
{
    writer.Write("Hello");
}   // Dispose() runs here — file handle released even if an exception occurs

Implement IDisposable whenever your class holds unmanaged resources: files, database connections, network sockets.

• Any type that implements IEnumerable<T> can be used in a foreach loop
• List<T>, arrays, Queue<T>, Stack<T> — all implement it; that is why foreach works on all of them uniformly
• LINQ (Where, Select, OrderBy, ...) operates on IEnumerable<T> — write it once, works on any collection
• When a method returns IEnumerable<T> instead of List<T>, callers only depend on the ability to iterate — the internal representation can change freely

1. Define an interface IPrintable with one method: void Print()
2. Create a Book class with Title and Author properties that implements IPrintable — Print() writes "Book: {Title} by {Author}"
3. Create a Movie class with Title and Year properties that implements IPrintable — Print() writes "Movie: {Title} ({Year})"
4. Create a List<IPrintable> containing several books and movies, loop over it, and call Print() on each item

• Polymorphism comes in two forms: compile-time (overloading) and runtime (overriding) — the runtime form is the more powerful design tool
• is pattern matching and the as operator provide safe type checking and casting without exceptions
• An abstract class defines a partial contract — it can hold state and shared logic, but cannot be instantiated directly
• An interface defines a pure contract — no state, no constructors, but a class can implement many at once
• Choose abstract class for IS-A with shared state; choose interface for CAN-DO capabilities across unrelated types
• IComparable<T>, IDisposable, and IEnumerable<T> are three fundamental .NET interfaces you will encounter constantly

Next session: Session 07 — C# Language Features: Enums, Generics, Collections & Delegates

• Enums for strongly-typed named constants
• Generic classes and methods — write once, work on any type
• List<T>, Dictionary<K,V>, Queue<T>, Stack<T>
• Delegates and lambda expressions — first-class functions in C#

Build a shape rendering system that exercises abstract classes, interfaces, and polymorphism.

• Define an interface IDrawable with a method void Draw()
• Define an abstract class Shape with an abstract double Area() method and a concrete void Describe() method that prints the class name and area
• Create Circle and Rectangle that extend Shape and implement IDrawable — each Draw() prints a short ASCII representation
• Store several shapes in a Shape[] and loop over them calling both Describe() and Draw()
• Add a Triangle class and verify that everything still compiles and runs without changing the loop