Understanding Interfaces in C#: Defining Contracts and Achieving Polymorphism

Learn about interfaces in C#, their role in defining contracts, and how they enable polymorphism and abstraction in object-oriented programming. This tutorial provides examples illustrating interface implementation, polymorphism, and the benefits of using interfaces for building flexible and maintainable C# applications.

Understanding Interfaces in C#

What is an Interface?

In C#, an interface is a reference type that defines a contract. It specifies a set of methods, properties, events, or indexers that a class or struct must implement. Interfaces cannot be instantiated directly; they serve as blueprints for classes. Interfaces are a core concept in object-oriented programming, enabling polymorphism and providing a way to achieve abstraction.

Key Characteristics of Interfaces

  • Abstract Methods: Interfaces only contain method signatures (declarations, not implementations). All methods in an interface are implicitly public and abstract.
  • Multiple Inheritance: A class can implement multiple interfaces (unlike class inheritance, where a class can only inherit from one base class).
  • Abstraction: Interfaces enforce abstraction by hiding implementation details; they specify *what* a class should do, not *how* it should do it.
  • Implementation: Classes that implement an interface must provide concrete implementations for all methods declared in the interface.

Example: Implementing an Interface

This example shows an interface (`Drawable`) with a `draw()` method. Two classes (`Rectangle` and `Circle`) implement this interface, providing their own versions of the `draw()` method. This demonstrates polymorphism, where different classes provide different implementations for the same method signature.

C# Code

using System;

public interface Drawable {
    void Draw();
}

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

// ... (Circle class and TestInterface class) ...

Note: You cannot explicitly use the `public` and `abstract` keywords in an interface method declaration; they are implicit.

Conclusion

Interfaces in C# are a powerful tool for promoting abstraction, polymorphism, and code reusability. They're a key component of well-structured object-oriented design.