C# Interface

Key Interface Concepts

interface IShape {
    double GetArea();
}

class Car : IVehicle, 
    IElectric { }

void Start();
void Stop();

public void Start() {
    // required
}

🔹 Basic Interface Example

An interface defines a contract—method signatures, properties, or events—without implementation. A Car class implementing an IVehicle interface must provide concrete methods for Start, Stop, and a Speed property. Interfaces enable polymorphism and loose coupling; code can depend on IVehicle rather than a specific class. This is foundational for dependency injection and designing flexible, modular systems.

interface IVehicle {
    void Start();
    void Stop();
    int GetSpeed();
}

class Car : IVehicle {
    private int speed = 0;
    
    public void Start() {
        Console.WriteLine("Car started");
        speed = 50;
    }
    
    public void Stop() {
        Console.WriteLine("Car stopped");
        speed = 0;
    }
    
    public int GetSpeed() {
        return speed;
    }
}

// Usage
IVehicle myCar = new Car();
myCar.Start();
Console.WriteLine($"Speed: {myCar.GetSpeed()} km/h");
myCar.Stop();

🔹 Multiple Interface Implementation

A single class can implement multiple interfaces, combining capabilities from different contracts. A SmartDevice might implement both IPlayable and IRecordable. This supports granular, role-based design without the limitations of single inheritance. Interfaces allow classes to fulfill diverse responsibilities, promoting flexibility and composition over inheritance. It's a common pattern in media players and plugin architectures.

interface IPlayable {
    void Play();
}

interface IRecordable {
    void Record();
}

class MediaPlayer : IPlayable, IRecordable {
    public void Play() {
        Console.WriteLine("Playing media...");
    }
    
    public void Record() {
        Console.WriteLine("Recording media...");
    }
}

// Usage
MediaPlayer player = new MediaPlayer();
player.Play();
player.Record();

🔹 Interface with Properties

Interfaces can declare properties, requiring implementing classes to define getters and setters. An IPerson interface might mandate Name and Age properties, ensuring consistent data access. A Student class then provides these properties alongside additional members like School. This enforces a uniform structure across different implementations, facilitating code that works with IPerson references and guaranteed property availability.

interface IPerson {
    string Name { get; set; }
    int Age { get; set; }
    void Introduce();
}

class Student : IPerson {
    public string Name { get; set; }
    public int Age { get; set; }
    public string School { get; set; }
    
    public void Introduce() {
        Console.WriteLine($"Hi, I'm {Name}, {Age} years old");
        Console.WriteLine($"I study at {School}");
    }
}

// Usage
IPerson student = new Student {
    Name = "Emma",
    Age = 20,
    School = "MIT"
};
student.Introduce();

🔹 Interface Inheritance

Interfaces can inherit from other interfaces, forming a hierarchy of contracts. IColoredShape might inherit from IShape, adding a Color property. A class implementing IColoredShape must satisfy both interfaces. This allows for specialized, incremental contracts and avoids bloating a single interface. It's used in graphics libraries and API design to create layered abstractions.

interface IShape {
    double GetArea();
}

interface IColoredShape : IShape {
    string GetColor();
}

class Circle : IColoredShape {
    public double Radius = 5;
    public string Color = "Red";
    
    public double GetArea() {
        return 3.14 * Radius * Radius;
    }
    
    public string GetColor() {
        return Color;
    }
}

// Usage
IColoredShape circle = new Circle();
Console.WriteLine($"Area: {circle.GetArea()}");
Console.WriteLine($"Color: {circle.GetColor()}");

🔹 Real-World Example

Interfaces enable dependency injection and loosely coupled architectures. In payment processing, an IPaymentGateway interface allows switching between CreditCardProcessor or PayPalProcessor without changing core logic. The system validates and processes payments through the interface, adhering to the Open/Closed Principle. This makes applications testable, maintainable, and adaptable to new payment methods.

interface IPaymentProcessor {
    void ProcessPayment(double amount);
    bool ValidatePayment();
}

class CreditCardProcessor : IPaymentProcessor {
    public void ProcessPayment(double amount) {
        Console.WriteLine($"Processing ${amount} via Credit Card");
    }
    
    public bool ValidatePayment() {
        Console.WriteLine("Credit card validated");
        return true;
    }
}

class PayPalProcessor : IPaymentProcessor {
    public void ProcessPayment(double amount) {
        Console.WriteLine($"Processing ${amount} via PayPal");
    }
    
    public bool ValidatePayment() {
        Console.WriteLine("PayPal account validated");
        return true;
    }
}

// Usage
IPaymentProcessor payment = new CreditCardProcessor();
if (payment.ValidatePayment()) {
    payment.ProcessPayment(99.99);
}