Overview

Interfaces in Object-Oriented Programming (OOP) serve as a blueprint for classes, ensuring they adhere to a specific contract. This concept is crucial for designing loosely coupled, scalable, and maintainable systems. Interfaces allow for polymorphism and abstraction, enabling developers to write more generic and flexible code.

Key Concepts

1. Contract Enforcement: Interfaces define a contract for classes, specifying what methods or properties the implementing class must have.
2. Decoupling: Interfaces help in decoupling the implementation from its usage, making the system more modular and easier to update or replace components.
3. Multiple Inheritance: Through interfaces, C# supports a form of multiple inheritance, allowing a class to inherit behaviors from multiple sources.

Common Interview Questions

Basic Level

1. What is an interface in OOP, and how does it differ from an abstract class?
2. Can you write a simple interface in C# and a class that implements it?

Intermediate Level

3. How do interfaces promote loose coupling in software design?

Advanced Level

4. Discuss the use of interfaces for dependency injection and its benefits in software architecture.

Detailed Answers

1. What is an interface in OOP, and how does it differ from an abstract class?

Answer: An interface in OOP is a contract that defines a set of methods or properties that any class implementing the interface must provide. Unlike abstract classes, interfaces cannot contain any implementation of the methods; they only declare method signatures. Interfaces support multiple inheritance, whereas abstract classes do not.

Key Points:
- Interfaces only declare signatures without implementation.
- Abstract classes can provide some implementation.
- A class can implement multiple interfaces but can inherit from only one abstract class.

Example:

interface IVehicle
{
    void Drive();
    int Wheels { get; }
}

// Implementing the IVehicle interface
class Car : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("Car is driving");
    }

    public int Wheels => 4; // Property implementation
}

2. Can you write a simple interface in C# and a class that implements it?

Answer: Yes, below is an example of a simple interface and a class implementing this interface.

Key Points:
- Define an interface using the interface keyword.
- Implement the interface methods in the class.
- A class can implement multiple interfaces.

Example:

interface IAnimal
{
    void Speak();
}

class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Bark");
    }
}

3. How do interfaces promote loose coupling in software design?

Answer: Interfaces promote loose coupling by acting as a contract between different parts of a program. By programming to an interface rather than to a concrete implementation, you can change the underlying implementation without affecting the components that use the interface. This makes the system more modular and easier to maintain, test, and extend.

Key Points:
- Interfaces abstract the implementation details.
- Changes in the implementation do not affect the interface consumers.
- Facilitates easier unit testing by allowing mocking of dependencies.

Example:

interface IRepository
{
    void Save(object data);
}

class FileRepository : IRepository
{
    public void Save(object data)
    {
        // Save to file
    }
}

class DatabaseRepository : IRepository
{
    public void Save(object data)
    {
        // Save to database
    }
}

4. Discuss the use of interfaces for dependency injection and its benefits in software architecture.

Answer: Interfaces are foundational to implementing dependency injection (DI), a technique where the dependencies of a class are supplied externally rather than instantiated within the class. DI allows for more flexible and testable code, as dependencies can be swapped easily, especially when combined with interfaces.

Key Points:
- Decouples class dependencies, allowing for independent development and testing.
- Enhances code reusability and scalability.
- Supports the inversion of control (IoC) principle, improving code manageability.

Example:

public interface IMessageService
{
    void SendMessage(string message);
}

public class EmailService : IMessageService
{
    public void SendMessage(string message)
    {
        // Send email with the message
    }
}

public class NotificationService
{
    private IMessageService _messageService;

    public NotificationService(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void Notify(string message)
    {
        _messageService.SendMessage(message);
    }
}

In this example, NotificationService is loosely coupled with the message sending mechanism, allowing for easy substitution and testing.