Interfaces in C#

Learn how interfaces define a common contract and help build flexible, reusable, and maintainable C# applications.

What is an Interface?

An interface in C# is a contract that defines a set of members that a class or structure must implement.

An interface describes what a class should do but generally does not define how the class should perform that operation.

Interfaces are widely used in real-world .NET applications for loose coupling, dependency injection, testing, and flexible application design.

Interface Syntax

An interface is declared using the interface keyword.

interface IAnimal
{
    void Sound();
}

A class can implement the interface by using the : symbol.

class Dog : IAnimal
{
    public void Sound()
    {
        Console.WriteLine("Dog barks");
    }
}

Simple Interface Example

using System;
 
interface IAnimal
{
    void Sound();
}

class Dog : IAnimal
{
    public void Sound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main()
    {
        Dog dog = new Dog();

        dog.Sound();
    }
}

Dog barks

Interface Reference

An interface reference can hold an object of a class that implements that interface.

using System;
 
interface IAnimal
{
    void Sound();
}

class Dog : IAnimal
{
    public void Sound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main()
    {
        IAnimal animal = new Dog();

        animal.Sound();
    }
}

Dog barks

Implementing Multiple Interfaces

A class can implement more than one interface. This is one of the important advantages of interfaces in C#.

using System;
 
interface IPrintable
{
    void Print();
}

interface IScannable
{
    void Scan();
}

class Printer : IPrintable, IScannable
{
    public void Print()
    {
        Console.WriteLine("Printing document");
    }

    public void Scan()
    {
        Console.WriteLine("Scanning document");
    }
}

class Program
{
    static void Main()
    {
        Printer printer = new Printer();

        printer.Print();
        printer.Scan();
    }
}

Printing document
Scanning document

Interfaces with Properties

Interfaces can also define properties that implementing classes must provide.

interface IEmployee
{
    int EmployeeId { get; set; }

    string Name { get; set; }
}

class Employee : IEmployee
{
    public int EmployeeId { get; set; }

    public string Name { get; set; }
}

Example: Payment System ❤️👨‍🏫

Interfaces are commonly used in real-world applications where multiple classes need to follow the same contract.

For example, an application can support Credit Card, UPI, and Cash payments.

using System;
 
interface IPayment
{
    void Pay(decimal amount);
}

class CreditCardPayment : IPayment
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using Credit Card");
    }
}

class UPIPayment : IPayment
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using UPI");
    }
}

class Program
{
    static void Main()
    {
        IPayment payment;

        payment = new CreditCardPayment();
        payment.Pay(5000);

        payment = new UPIPayment();
        payment.Pay(2500);
    }
}

Paid 5000 using Credit Card
Paid 2500 using UPI

Interface vs Abstract Class

Interfaces and Polymorphism

Interfaces can also be used to achieve polymorphism. An interface reference can refer to objects of different implementing classes.

using System;
 
interface IShape
{
    void Draw();
}

class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing Circle");
    }
}

class Rectangle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing Rectangle");
    }
}

class Program
{
    static void Main()
    {
        IShape shape;

        shape = new Circle();
        shape.Draw();

        shape = new Rectangle();
        shape.Draw();
    }
}

Drawing Circle
Drawing Rectangle

Explicit Interface Implementation

C# allows a class to implement an interface member explicitly. This is useful when two interfaces contain methods with the same name but require different implementations.

using System;
 
interface IPrinter
{
    void Print();
}

interface IScanner
{
    void Print();
}

class Machine : IPrinter, IScanner
{
    void IPrinter.Print()
    {
        Console.WriteLine("Printer is printing");
    }

    void IScanner.Print()
    {
        Console.WriteLine("Scanner is scanning");
    }
}

class Program
{
    static void Main()
    {
        IPrinter printer = new Machine();
        IScanner scanner = new Machine();

        printer.Print();
        scanner.Print();
    }
}

Printer is printing
                            Scanner is scanning

Advantages of Interfaces

• Provides a clear contract between components.
• Supports loose coupling.
• Supports multiple interface implementation.
• Makes applications easier to maintain.
• Makes unit testing easier.
• Supports dependency injection.
• Helps achieve flexible application architecture.
• Encourages reusable and modular code.

CIIT Practical Point

Common Mistakes

1. Forgetting to implement all required interface members.
2. Trying to create an object directly from an interface.
3. Confusing interfaces with inheritance from a base class.
4. Creating unnecessary interfaces without a clear purpose.
5. Not following meaningful interface naming conventions.

Important Interview Points

• What is an interface in C#?
• Why do we use interfaces?
• How do you implement an interface?
• Can a class implement multiple interfaces?
• Can an interface inherit another interface?
• Difference between interface and abstract class?
• What is explicit interface implementation?
• Can an interface reference hold a class object?
• How are interfaces related to polymorphism?
• How are interfaces used in dependency injection?

Practice Questions

1. Create an IVehicle interface with Start() and Stop() methods.
2. Implement the interface in Car and Bike classes.
3. Create two interfaces and implement both in a single class.
4. Create an IPayment interface and implement Credit Card and UPI payment classes.
5. Create an interface reference and demonstrate polymorphism.