📝 Lesson 5.2: Interfaces

What Is an Interface?

An interface defines a set of members (methods and properties) that a class promises to provide — but it contains no implementation itself. It's a pure contract: "any class that implements me will have these abilities."

A great analogy is a job description. It lists the responsibilities ("must be able to take payment," "must be able to open the store") without saying who does them or how. Different people (classes) can each fulfill the same job description in their own way.

The key difference from inheritance: a class can inherit from only one base class, but it can implement many interfaces — and interfaces cut across unrelated class families.

Defining and Implementing

You declare an interface with the interface keyword. By strong convention, interface names start with a capital I (e.g. IPlayable). The members have no body — just their signatures:

interface IPlayable
{
    void Play();          // no body — just the promise
    void Stop();
}

A class implements an interface using the same : syntax as inheritance, and must provide a real body for every member the interface requires:

class MusicTrack : IPlayable
{
    public string Title { get; set; }

    public void Play()
    {
        Console.WriteLine($"♪ Playing '{Title}'");
    }

    public void Stop()
    {
        Console.WriteLine($"■ Stopped '{Title}'");
    }
}

MusicTrack song = new MusicTrack { Title = "C# Blues" };
song.Play();   // ♪ Playing 'C# Blues'
song.Stop();   // ■ Stopped 'C# Blues'

Programming to an Interface

Here's where interfaces become powerful. You can write code that works with the interface type instead of any specific class. That code then works with any class that implements the interface — including ones you haven't written yet.

class Podcast : IPlayable
{
    public void Play() { Console.WriteLine("▶ Playing a podcast episode"); }
    public void Stop() { Console.WriteLine("■ Podcast paused"); }
}

// This method accepts ANY IPlayable — song, podcast, anything
void PlayItTwice(IPlayable item)
{
    item.Play();
    item.Stop();
    item.Play();
}

PlayItTwice(new MusicTrack { Title = "C# Blues" });
PlayItTwice(new Podcast());

♪ Playing 'C# Blues'
■ Stopped 'C# Blues'
♪ Playing 'C# Blues'
▶ Playing a podcast episode
■ Podcast paused
▶ Playing a podcast episode

You can also hold different concrete types in one List of the interface type — even though MusicTrack and Podcast are otherwise unrelated:

List<IPlayable> playlist = new List<IPlayable>
{
    new MusicTrack { Title = "C# Blues" },
    new Podcast()
};

foreach (IPlayable item in playlist)
{
    item.Play();     // each runs its own version
}

Implementing Multiple Interfaces

A class can only inherit one base class, but it can implement as many interfaces as it needs — just separate them with commas. This lets you compose capabilities freely:

interface IPlayable
{
    void Play();
}

interface IDownloadable
{
    void Download();
}

// A class can promise BOTH capabilities
class MusicTrack : IPlayable, IDownloadable
{
    public string Title { get; set; }

    public void Play()     { Console.WriteLine($"♪ Playing '{Title}'"); }
    public void Download() { Console.WriteLine($"⬇ Downloading '{Title}'"); }
}

MusicTrack song = new MusicTrack { Title = "C# Blues" };
song.Play();       // works because it's IPlayable
song.Download();   // works because it's IDownloadable

class MusicTrack : MediaItem, IPlayable, IDownloadable
{
    // ...
}

Interface vs. Inheritance

Both use the : syntax, so how do you choose? It comes down to "is-a" versus "can-do".

💡 A quick test: If you'd say a class is a kind of something → inheritance. If you'd say a class is able to do something → interface. A FileLogger is a Logger (inheritance), but many unrelated things can be IDisposable (interface).

Interfaces in .NET

You've already been using interfaces without knowing it. .NET is full of them, and recognizing the common ones helps you read real code:

For example, implementing IComparable<T> teaches C# how to sort your own type:

class Player : IComparable<Player>
{
    public string Name { get; set; }
    public int Score { get; set; }

    // Contract from IComparable: define how two players compare
    public int CompareTo(Player other)
    {
        return Score.CompareTo(other.Score);   // sort by score
    }
}

Because Player now honors the IComparable<Player> contract, built-in tools like list.Sort() know how to order players — you plugged your class into machinery .NET already had.

Exercise & Quiz

Alert(new EmailNotifier(), "Server is down!");
Alert(new SmsNotifier(), "Server is down!");

void Alert(INotifier notifier, string message)
{
    notifier.Send(message);
}

interface INotifier
{
    void Send(string message);
}

// TODO: EmailNotifier : INotifier
// TODO: SmsNotifier : INotifier

Alert(new EmailNotifier(), "Server is down!");
Alert(new SmsNotifier(), "Server is down!");

// Bonus: broadcast through all notifiers
List<INotifier> channels = new List<INotifier>
{
    new EmailNotifier(),
    new SmsNotifier()
};
foreach (INotifier channel in channels)
{
    channel.Send("Nightly backup complete.");
}

void Alert(INotifier notifier, string message)
{
    notifier.Send(message);
}

interface INotifier
{
    void Send(string message);
}

class EmailNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"Email: {message}");
    }
}

class SmsNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"SMS: {message}");
    }
}

Email: Server is down!
SMS: Server is down!
Email: Nightly backup complete.
SMS: Nightly backup complete.

Summary

📚 Additional Resources

• Interfaces — Microsoft Docs
• The interface keyword — reference
• IComparable<T> — API reference

🚀 What's Next?

You've now met both ways to relate classes: inheritance and interfaces. In the final lesson, Lesson 5.3: Polymorphism and Abstract Classes, we bring it all together — writing code that treats many different types uniformly, and using abstract classes to define partial blueprints.