C# - Interfaces

Interfaces in C#

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

Key Features of Interfaces in C#:

Declaration:

• Use the interface keyword to define an interface.
• By default, all members are public and cannot have access modifiers.

Implementation

• A class or struct that implements an interface must provide concrete implementations for all its members.
• A class can implement multiple interfaces.

Polymorphism:

• Interfaces enable polymorphism by allowing you to use different implementations interchangeably.

No Fields or Constructors:

• Interfaces cannot contain fields, static constructors, or instance constructors.

Example

public interface IAnimal
{
    void Speak(); // Method declaration
    string Name { get; set; } // Property declaration
}

//Implement
public class Dog : IAnimal
{
    public string Name { get; set; }
    
    public void Speak()
    {
        Console.WriteLine("Woof! Woof!");
    }
}


//Usage
class Program
{
    static void Main()
    {
        IAnimal animal = new Dog { Name = "Buddy" };
        Console.WriteLine(animal.Name); // Output: Buddy
        animal.Speak();                // Output: Woof! Woof!
    }
}

Multiple Inheritance in C#:

In programming, multiple inheritance refers to a class inheriting features (methods, properties, fields) from more than one base class.

C# does not support multiple inheritance for classes, meaning a class cannot directly inherit from more than one class. However, C# allows multiple inheritance through interfaces, enabling a class to implement multiple interfaces.

Why Does C# Not Support Multiple Inheritance for Classes?

Diamond Problem:

• Multiple inheritance can create ambiguities when two base classes have methods or properties with the same name.
• For example, if both parent classes define a method with the same name, the derived class might face confusion about which implementation to inherit.

       ClassA
        /  \
   ClassB  ClassC
        \  /
       ClassD

If ClassD inherits from both ClassB and ClassC, which both inherit from ClassA, ambiguities arise if ClassA has a method that is overridden by both ClassB and ClassC.

How Does C# Handle Multiple Inheritance?

C# allows multiple inheritance only through interfaces. A class can implement multiple interfaces, providing a way to simulate multiple inheritance.

Example: Multiple Inheritance Using Interfaces

// Define two interfaces
public interface IAnimal
{
    void Eat();
}

public interface IBird
{
    void Fly();
}

// Implement both interfaces in a single class
public class Bat : IAnimal, IBird
{
    public void Eat()
    {
        Console.WriteLine("Bat is eating insects.");
    }

    public void Fly()
    {
        Console.WriteLine("Bat is flying.");
    }
}

class Program
{
    static void Main()
    {
        Bat bat = new Bat();
        bat.Eat(); // Output: Bat is eating insects.
        bat.Fly(); // Output: Bat is flying.
    }
}