O interfață definește un contract — un set de membri (metode, proprietăți) pe care clasele care o implementează trebuie să le furnizeze, fără implementare (în mod tradițional). O clasă poate implementa multiple interfețe, ceea ce le face esențiale pentru design flexibil, decuplat și testabil în C#.
{
;
Name { ; }
}
:
{
Radius { ; ; }
=> Math.PI * Radius * Radius;
Name => ;
}
O interfață (numită IXxx prin convenție) declară membri fără implementare; o clasă care o implementează trebuie să le furnizeze. (Din C# 8 în sus, interfețele pot avea implementări implicite, dar rolul de contract este principal.)
public class Widget : IDrawable, ISerializable, IComparable<Widget>
{
// must implement ALL members of ALL interfaces
}
O clasă poate implementa multe interfețe (spre deosebire de moștenirea unică de clase) — modul C# de a partaja capabilități între tipuri neînrudite.
// 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)
Interfețele sunt centrale în design-ul bun în C# și sunt fundamentale pentru modul în care framework-ul .NET și aplicațiile C# moderne sunt structurate, deci înțelegerea lor este esențială.
Interfețele definesc contracte (ce poate face un tip) fără implementare, și o clasă poate implementa multiple interfețe — ceea ce le face principalul instrument al C# pentru design flexibil și decuplat, și răspunsul la limitările moștenirii unice (partajarea capabilităților între tipuri neînrudite).
Beneficiul cel mai important este activarea decuplării loose și testabilității: prin dependență de interfețe în loc de clase concrete ("programare după o interfață"), codul devine flexibil (schimbă implementări) și extrem de testabil (injectează implementări mock în teste — un motiv major pentru care se pune accent pe interfețe, deoarece le fac injecția dependențelor și testarea unitară practice).
Interfețele permit de asemenea polimorfism (tratarea diferitelor implementări uniform prin tipul interfață).
Înțelegerea interfețelor — definirea contractelor, implementarea multiplelor, programarea după interfețe pentru decuplare și testabilitate, și interfețele .NET frecvente (IEnumerable, IDisposable, etc.) — este cunoștință importantă pentru proiectarea aplicațiilor C# ușor de întreținut și testabil, și pentru lucrul cu framework-ul (care este construit în jurul interfețelor).
Cum interfețele sunt fundamentale pentru injecția dependențelor, testabilitate și arhitectură flexibilă — toate caracteristicile design-ului profesional în C# — și apar pretutindeni în .NET, stăpânirea lor este o cunoștință centrală, frecvent aplicată, care deosebește codul C# bine arhitecturat și testabil de codul strâns cuplat, și este un subiect frecvent în interviuri reflectând înțelegerea principiilor bune de design.