Wat zijn interfaces in C#?

Question

Accepted Answer

Een **interface** definieert een **contract** — een verzameling leden (methoden, eigenschappen) die implementerende klassen moeten bieden, zonder implementatie (traditioneel). Een klasse kan **meerdere** interfaces implementeren, wat ze essentieel maakt voor flexibel, ontkoppeld en testbaar ontwerp in C#. ## Interfaces definiëren en implementeren ```csharp public interface IShape { double Area(); // a method signature (no body) string Name { get; } // a property } public class Circle : IShape // implement the interface { public double Radius { get; set; } public double Area() => Math.PI * Radius * Radius; // must implement public string Name => "Circle"; } ``` Een interface (volgens afspraak genoemd `IXxx`) declareert leden zonder implementatie; een klasse die deze implementeert **moet** deze voorzien. (Sinds C# 8 kunnen interfaces *standaard*implementaties hebben, maar de contractrol is primair.) ## Meerdere interfaces (versus enkele overerving) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` Een klasse kan **veel** interfaces implementeren (anders dan enkele klasseovererving) — C#'s manier om mogelijkheden over onrelated types te delen. ## Polymorfisme via interfaces (het belangrijkste voordeel) ```csharp // program to the INTERFACE — works with ANY implementation List 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 ``` ## Veelgebruikte .NET-interfaces en testbaarheid ```csharp IEnumerable, IDisposable, IComparable, IEquatable // 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) ``` ## Waarom het belangrijk is Interfaces zijn centraal voor goed C#-ontwerp en fundamenteel voor hoe het .NET-framework en moderne C#-toepassingen zijn opgebouwd, dus het begrijpen ervan is essentieel. Interfaces definiëren **contracten** (wat een type kan doen) zonder implementatie, en een klasse kan **meerdere** interfaces implementeren — wat ze C#'s primaire instrument maakt voor flexibel, ontkoppeld ontwerp en het antwoord op beperkingen van enkele overerving (mogelijkheden delen over onrelated types). Het belangrijkste voordeel is het mogelijk maken van **losse koppeling en testbaarheid**: door afhankelijk te zijn van interfaces in plaats van concrete klassen ("programmeren voor een interface"), wordt code flexibel (implementaties verwisselen) en zeer **testbaar** (mock-implementaties in tests injecteren — een belangrijke reden waarom interfaces benadrukt worden, omdat ze dependency injection en unit testing praktisch maken). Interfaces maken ook **polymorfisme** mogelijk (verschillende implementaties uniform behandelen via het interfacetype). Het begrijpen van interfaces — contracten definiëren, meerdere implementeren, naar interfaces programmeren voor ontkoppeling en testbaarheid, en de veelgebruikte .NET-interfaces (`IEnumerable`, `IDisposable`, etc.) — is belangrijke kennis voor het ontwerpen van onderhoudbare, testbare C#-toepassingen en voor het werken met het framework (dat rond interfaces is gebouwd). Omdat interfaces dependency injection, testbaarheid en flexibele architectuur ondersteunen — allemaal kenmerken van professionele C# — en overal in .NET voorkomen, is het beheersen ervan kernkennis die veelvuldig wordt toegepast en onderscheidt goed gearchitecteerde, testbare C# van strak gekoppelde code, en is het een veelvoorkomen interviewonderwerp dat begrip van goede ontwerpprincipes weerspiegelt.