Complete C# Tutorial

leafMan illustration
Updated on March 26, 2025

Interface in C# – The Secret to Flexible Code!

Hey there, coder! 👋 Have you ever wondered how to make your code more flexible and future-proof? That’s where Interface in C# comes into play!

An interface helps you define a contract that multiple classes can follow. Think of it like a set of rules that classes must obey, without worrying about how they do it! 🤯

Let’s dive into Interface in C# and see how it works! 💡

🔍 What is an Interface in C#?

An interface in C# is like a blueprint that defines what a class should do, but not how it should do it.

✅ It only contains method signatures (no implementation).
✅ A class that implements an interface must define those methods.
✅ It helps in achieving multiple inheritance (which classes in C# can’t do).

 

💡 Example: Interface as a Contract

Think of an interface like an electrical socket. It tells us:

✅ What type of plug can be used.
✅ What voltage it supports.

But it doesn’t care what brand of appliance you plug in—just that it follows the rules! 🏡⚡

💡 How to Define and Use an Interface in C#?

Here’s a simple example to understand how an interface in C# works!

 

✅ Step 1: Define an Interface

				
					interface IAnimal  
{
    void MakeSound();  // Method without implementation
}
  • The IAnimal interface defines a contract.
  • Any class that implements IAnimal must define the MakeSound() method.

 

✅ Step 2: Implement the Interface in a Class

				
					class Dog : IAnimal  
{
    public void MakeSound()  
    {
        Console.WriteLine("Woof! 🐶");  
    }
}
  • The Dog class implements the IAnimal interface.
  • It must provide an implementation for MakeSound().

 

✅ Step 3: Use the Interface in a Program

				
					class Program  
{
    static void Main()  
    {
        IAnimal myDog = new Dog();  // Using interface reference
        myDog.MakeSound();  // Output: Woof! 🐶  
    }
}
  • We created an IAnimal reference and assigned a Dog object to it.
  • This allows loose coupling, meaning we can easily swap Dog with another class that implements IAnimal.

 

Output
				
					Woof! 🐶

💡 Different Types of Interfaces in C# (With Examples!)

Let’s go through four types of interfaces with simple examples to make learning easy!

1️⃣ Basic Interface – Defining a Contract

An interface in C# is simply a contract. Let’s create a basic interface and implement it in a class.

				
					using System;

interface IVehicle  
{
    void Start();  // Method without implementation
}

class Car : IVehicle  
{
    public void Start()  
    {
        Console.WriteLine("Car is starting... 🚗");  
    }
}

class Program  
{
    static void Main()  
    {
        IVehicle myCar = new Car();  
        myCar.Start();  // Output: Car is starting... 🚗  
    }
}
🖥️ Output:
				
					Car is starting... 🚗

📝 Explanation:

  • IVehicle defines a contract with a Start() method.
  • Car implements IVehicle and must define Start().
  • In Main(), we use an interface reference (IVehicle myCar = new Car();), which allows loose coupling.

2️⃣ Interface with Multiple Implementations

A single interface can be implemented by multiple classes, each providing its own version of behavior!

				
					using System;

interface IAnimal  
{
    void MakeSound();
}

class Dog : IAnimal  
{
    public void MakeSound()  
    {
        Console.WriteLine("Woof! 🐶");  
    }
}

class Cat : IAnimal  
{
    public void MakeSound()  
    {
        Console.WriteLine("Meow! 🐱");  
    }
}

class Program  
{
    static void Main()  
    {
        IAnimal myDog = new Dog();
        myDog.MakeSound();  // Output: Woof! 🐶

        IAnimal myCat = new Cat();
        myCat.MakeSound();  // Output: Meow! 🐱
    }
}
🖥️ Output:
				
					Woof! 🐶
Meow! 🐱

📝 Explanation:

  • IAnimal is an interface with a MakeSound() method.
  • Dog and Cat both implement IAnimal, but they define MakeSound() differently.
  • This is an example of polymorphism, where different classes use the same method in different ways.

3️⃣ Multiple Interface Implementation (C# Supports Multiple Inheritance with Interfaces!)

Unlike classes, a class in C# can implement multiple interfaces!

				
					using System;

interface IFlyable  
{
    void Fly();
}

interface IWalkable  
{
    void Walk();
}

class Bird : IFlyable, IWalkable  
{
    public void Fly()  
    {
        Console.WriteLine("Flying high! 🦅");  
    }

    public void Walk()  
    {
        Console.WriteLine("Walking on the ground! 🐦");  
    }
}

class Program  
{
    static void Main()  
    {
        Bird myBird = new Bird();
        myBird.Fly();   // Output: Flying high! 🦅
        myBird.Walk();  // Output: Walking on the ground! 🐦
    }
}
🖥️ Output:
				
					Flying high! 🦅
Walking on the ground! 🐦

📝 Explanation:

  • Bird implements two interfaces: IFlyable and IWalkable.
  • It must define both Fly() and Walk() methods.
  • This allows a class to inherit behaviors from multiple sources, which isn’t possible with abstract classes.

4️⃣ Explicit Interface Implementation (Avoiding Naming Conflicts)

When a class implements multiple interfaces with the same method name, explicit interface implementation helps!

				
					using System;

interface IPrinter  
{
    void Print();
}

interface IScanner  
{
    void Print();
}

class OfficeMachine : IPrinter, IScanner  
{
    void IPrinter.Print()  
    {
        Console.WriteLine("Printing document... 🖨️");  
    }

    void IScanner.Print()  
    {
        Console.WriteLine("Scanning document... 📄");  
    }
}

class Program  
{
    static void Main()  
    {
        OfficeMachine machine = new OfficeMachine();

        ((IPrinter)machine).Print();  // Output: Printing document... 🖨️
        ((IScanner)machine).Print();  // Output: Scanning document... 📄
    }
}
🖥️ Output:
				
					Printing document... 🖨️
Scanning document... 📄

📝 Explanation:

  • IPrinter and IScanner both have a Print() method.
  • OfficeMachine implements both interfaces explicitly to avoid conflicts.
  • To call the correct method, we cast the object to the required interface.

🎯 Conclusions

✅ Interfaces help define a clear contract for your classes.
✅ They allow flexibility, scalability, and better code organization.
✅ You can implement multiple interfaces in a class, unlike abstract classes.
✅ They promote loose coupling, making code easier to maintain and test.

By now, you should have a solid understanding of Interface in C# and how to use it in real-world projects! 🎉

 

🚀 Next What?

Awesome! 🎯 You’ve learned what an interface in C# is, why it’s useful, and how to implement different types of interfaces with examples. Now, let’s take it to the next level! 🚀

In the next lesson, you’ll dive into:

✔️ Best practices for designing interfaces
✔️ Common mistakes to avoid when using interfaces
✔️ How to write clean and maintainable code with interfaces
✔️ Performance considerations when using interfaces in large applications

By mastering these best practices, you’ll be able to write flexible, scalable, and professional C# code like a pro! 💡

Ready? Let’s keep going and learn the Best Practices and Guidelines for Interfaces in C#! 🎉💻

← OOPs – Interface
Best Practices & Common Mistakes →

Leave a Comment

Share this Doc

Interfaces in C#

Or copy link