Interfaces

🎭 C# Interfaces: The Universal Remote Control

The Big Idea

Imagine you have a universal remote control that works with any TV. It doesn’t matter if it’s a Samsung, LG, or Sony. The remote has buttons like “Power,” “Volume Up,” and “Channel.” Every TV promises to respond to these buttons, even though each TV does it in its own way inside.

That’s exactly what an interface is in C#!

An interface is like a promise or a contract. It says: “If you want to be part of this club, you MUST have these abilities.”

🎯 What You’ll Learn

1. Interface Fundamentals – What interfaces are and why they matter
2. Interface Implementation – How to make classes follow the contract
3. Default Interface Methods – The modern twist that adds flexibility

Part 1: Interface Fundamentals

What Is an Interface?

Think of an interface as a job description.

When you hire a “Driver,” you expect them to:

• Start the car
• Stop the car
• Turn left or right

You don’t care HOW they do it. A taxi driver and a race car driver both “drive,” but they do it differently!

The C# Way

// This is a JOB DESCRIPTION
// Anyone who wants to be "Drivable"
// MUST have these abilities

public interface IDrivable
{
    void Start();
    void Stop();
    void Turn(string direction);
}

🔑 Key Points

Why Use Interfaces?

graph TD
    A["Interface: IPlayable"] --> B["Piano"]
    A --> C["Guitar"]
    A --> D["Drums"]

    style A fill:#FF6B6B,color:white
    style B fill:#4ECDC4,color:white
    style C fill:#45B7D1,color:white
    style D fill:#96CEB4,color:white

One interface, many instruments!

If your music app needs to play something, it doesn’t care if it’s a piano or guitar. It just calls Play() and the right thing happens!

Part 2: Interface Implementation

Making the Promise Real

Now let’s make a class that keeps the promise.

Simple Example: Animals That Speak

// The promise
public interface ISpeakable
{
    void Speak();
}

// Dog keeps the promise
public class Dog : ISpeakable
{
    public void Speak()
    {
        Console.WriteLine("Woof!");
    }
}

// Cat keeps the promise
public class Cat : ISpeakable
{
    public void Speak()
    {
        Console.WriteLine("Meow!");
    }
}

Using It

// Magic! Same code works for both
ISpeakable pet1 = new Dog();
ISpeakable pet2 = new Cat();

pet1.Speak();  // Output: Woof!
pet2.Speak();  // Output: Meow!

🎨 The Beautiful Part

You can have a list of different animals:

List<ISpeakable> pets = new List<ISpeakable>
{
    new Dog(),
    new Cat(),
    new Dog()
};

// All speak their own way!
foreach (var pet in pets)
{
    pet.Speak();
}
// Woof! Meow! Woof!

Multiple Interfaces

A class can implement MANY interfaces!

Think of it like this: A smartphone is:

• A phone (can call)
• A camera (can take photos)
• A music player (can play songs)

public interface ICallable
{
    void MakeCall(string number);
}

public interface ICamera
{
    void TakePhoto();
}

public interface IMusicPlayer
{
    void PlaySong(string name);
}

// One class, THREE abilities!
public class Smartphone :
    ICallable, ICamera, IMusicPlayer
{
    public void MakeCall(string number)
    {
        Console.WriteLine(quot;Calling {number}");
    }

    public void TakePhoto()
    {
        Console.WriteLine("📸 Click!");
    }

    public void PlaySong(string name)
    {
        Console.WriteLine(quot;🎵 Playing {name}");
    }
}

graph TD
    S["Smartphone"] --> A["ICallable"]
    S --> B["ICamera"]
    S --> C["IMusicPlayer"]

    style S fill:#667eea,color:white
    style A fill:#f093fb,color:white
    style B fill:#4facfe,color:white
    style C fill:#43e97b,color:white

Part 3: Default Interface Methods

The Modern Upgrade (C# 8.0+)

Here’s a problem: You have 100 classes using your interface. Now you want to add a new method. Do you edit all 100 classes?

NO! Use default interface methods.

Before (The Old Way)

If you added a new method to an interface, every class would break until you implemented it.

After (The New Way)

public interface ILogger
{
    void Log(string message);

    // Default method - already has a body!
    void LogError(string error)
    {
        Log(quot;ERROR: {error}");
    }
}

Now any class using ILogger automatically gets LogError() for free!

Real Example

public interface IGreeter
{
    string Name { get; }

    void SayHello();

    // Default method
    void SayGoodbye()
    {
        Console.WriteLine(quot;Goodbye from {Name}!");
    }
}

public class FriendlyBot : IGreeter
{
    public string Name => "Buddy";

    public void SayHello()
    {
        Console.WriteLine(quot;Hi! I'm {Name}!");
    }

    // We don't HAVE to implement SayGoodbye
    // But we CAN override it if we want!
}

Using It

IGreeter bot = new FriendlyBot();
bot.SayHello();    // Hi! I'm Buddy!
bot.SayGoodbye();  // Goodbye from Buddy!

Override If You Want

public class FormalBot : IGreeter
{
    public string Name => "Sir Reginald";

    public void SayHello()
    {
        Console.WriteLine(quot;Greetings. I am {Name}.");
    }

    // Override the default!
    public void SayGoodbye()
    {
        Console.WriteLine("Farewell, good citizen.");
    }
}

🌟 Quick Comparison

🎮 Putting It All Together

Let’s build a mini game system!

public interface IGameCharacter
{
    string Name { get; }
    int Health { get; set; }

    void Attack(IGameCharacter target);

    // Default method
    void Heal(int amount)
    {
        Health += amount;
        Console.WriteLine(quot;{Name} healed! HP: {Health}");
    }

    // Another default
    bool IsAlive() => Health > 0;
}

public class Warrior : IGameCharacter
{
    public string Name => "Conan";
    public int Health { get; set; } = 100;

    public void Attack(IGameCharacter target)
    {
        Console.WriteLine(quot;{Name} swings sword!");
        target.Health -= 20;
    }
}

public class Mage : IGameCharacter
{
    public string Name => "Gandalf";
    public int Health { get; set; } = 70;

    public void Attack(IGameCharacter target)
    {
        Console.WriteLine(quot;{Name} casts fireball!");
        target.Health -= 30;
    }

    // Override default heal
    public void Heal(int amount)
    {
        Health += amount * 2; // Mages heal better!
        Console.WriteLine(quot;{Name} magic heal! HP: {Health}");
    }
}

🎯 Remember This!

1. Interfaces = Contracts/Promises
2. Implementation = Keeping the promise your way
3. Default Methods = Free bonus features that work out of the box

🚀 You Did It!

You now understand C# interfaces! Think of them whenever you need:

• Multiple classes to share the same abilities
• Flexibility to swap implementations
• Clean, organized code

The universal remote is in your hands. Go control the world! 🎮