Creating Interfaces in C#

What are Interfaces in C#?

An interface in C# is a contract that defines a set of methods, properties, or events that a class must implement. It provides a way to achieve abstraction and multiple inheritance.

Key Features of Interfaces

• Defines a contract without implementation.
• A class can implement multiple interfaces, supporting multiple inheritance.
• Cannot contain fields or constructors.
• All methods in an interface are implicitly public and abstract.

Example: Defining and Implementing an Interface

The following example demonstrates how to define an interface and implement it in a class.

Example: Creating and Implementing an Interface

using System;

interface IAnimal
{
    void MakeSound(); // Method declaration
}

// Implementing the interface in a class
public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Dog barks!");
    }
}

// Usage
IAnimal myDog = new Dog();
myDog.MakeSound(); // Output: Dog barks!
        

In this example, the IAnimal interface defines a method MakeSound(), which is implemented in the Dog class.

Implementing Multiple Interfaces

A class can implement multiple interfaces, allowing multiple inheritance.

Example: Multiple Interface Implementation

interface IAnimal
{
    void MakeSound();
}

interface IPet
{
    void ShowAffection();
}

// Implementing both interfaces in a class
public class Dog : IAnimal, IPet
{
    public void MakeSound()
    {
        Console.WriteLine("Dog barks!");
    }

    public void ShowAffection()
    {
        Console.WriteLine("Dog wags its tail.");
    }
}

// Usage
Dog myDog = new Dog();
myDog.MakeSound();     // Output: Dog barks!
myDog.ShowAffection(); // Output: Dog wags its tail.
        

Here, the Dog class implements both IAnimal and IPet interfaces, demonstrating multiple inheritance.

Interfaces vs Abstract Classes

While both interfaces and abstract classes enable abstraction, they have key differences.

Default Methods in Interfaces (C# 8+)

Starting from C# 8.0, interfaces can have default implementations using the default keyword.

Example: Default Method in Interface

interface IAnimal
{
    void MakeSound();

    // Default implementation
    void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

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

// Usage
Dog myDog = new Dog();
myDog.MakeSound(); // Output: Dog barks!
// myDog.Sleep(); // Error: Default methods require explicit interface implementation

IAnimal animal = new Dog();
animal.Sleep(); // Output: Sleeping...
        

Here, the Sleep() method has a default implementation and must be accessed via an interface reference.

When to Use Interfaces?

• When multiple classes share common behavior but not implementation.
• To achieve multiple inheritance.
• To improve code maintainability and flexibility.
• For dependency injection and loose coupling in applications.