An interface defines a contract — a set of members (methods, properties) that implementing classes must provide, with no implementation (traditionally). A class can implement multiple interfaces, making them key to flexible, decoupled, testable design in C#.
{
;
Name { ; }
}
:
{
Radius { ; ; }
=> Math.PI * Radius * Radius;
Name => ;
}
An interface (named IXxx by convention) declares members without implementation; a class that implements it must provide them. (Since C# 8, interfaces can have default implementations, but the contract role is primary.)
public class Widget : IDrawable, ISerializable, IComparable<Widget>
{
// must implement ALL members of ALL interfaces
}
A class can implement many interfaces (unlike single class inheritance) — C#'s way to share capabilities across unrelated types.
// program to the INTERFACE — works with ANY implementation
List<IShape> shapes = new() { new Circle(), new Square() };
foreach (IShape s in shapes)
Console.WriteLine(s.Area()); // calls each type's implementation
void Process(IRepository repo) { } // depend on an interface, not a concrete class
IEnumerable<T>, IDisposable, IComparable<T>, IEquatable<T> // framework interfaces
// interfaces enable mocking in tests (depend on an interface, inject a mock)
public class Service(IEmailSender sender) { } // inject any IEmailSender (real or mock)
Interfaces are central to good C# design and are fundamental to how the .NET framework and modern C# applications are structured, so understanding them is essential.
Interfaces define contracts (what a type can do) without implementation, and a class can implement multiple interfaces — making them C#'s primary tool for flexible, decoupled design and its answer to single-inheritance limitations (sharing capabilities across unrelated types).
The most important benefit is enabling loose coupling and testability: by depending on interfaces rather than concrete classes ("program to an interface"), code becomes flexible (swap implementations) and highly testable (inject mock implementations in tests — a major reason interfaces are emphasized, since they make dependency injection and unit testing practical).
Interfaces also enable polymorphism (treating different implementations uniformly through the interface type).
Understanding interfaces — defining contracts, implementing multiple, programming to interfaces for decoupling and testability, and the common .NET interfaces (IEnumerable, IDisposable, etc.) — is important knowledge for designing maintainable, testable C# applications and for working with the framework (which is built around interfaces).
Since interfaces underpin dependency injection, testability, and flexible architecture — all hallmarks of professional C# — and appear throughout .NET, mastering them is core, frequently-applied knowledge that distinguishes well-architected, testable C# from tightly-coupled code, and a common interview topic reflecting understanding of good design principles.