Hva er interfaces i C#?

Question

Accepted Answer

Et **interface** definerer en **kontrakt** — et sett med medlemmer (metoder, egenskaper) som implementerende klasser må tilby, uten implementering (tradisjonelt). En klasse kan implementere **flere** interfaces, noe som gjør dem sentrale for fleksibel, løst koblet og testbar design i C#. ## Definere og implementere et interface ```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"; } ``` Et interface (navngitt `IXxx` etter konvensjon) deklarerer medlemmer uten implementering; en klasse som implementerer det **må** tilby dem. (Siden C# 8 kan interfaces ha *standard* implementeringer, men kontraktrollen er primær.) ## Flere interfaces (vs enkel arv) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` En klasse kan implementere **mange** interfaces (ulikt enkel klassearv) — C#s måte å dele muligheter på tvers av urelaterte typer. ## Polymorfisme gjennom interfaces (hovedfordelen) ```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 ``` ## Vanlige .NET-interfaces og testbarhet ```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) ``` ## Hvorfor det betyr noe Interfaces er sentrale i god C#-design og er fundamental for hvordan .NET-rammeverket og moderne C#-applikasjoner er strukturert, så forståelse av dem er essensielt. Interfaces definerer **kontrakter** (hva en type kan gjøre) uten implementering, og en klasse kan implementere **flere** interfaces — noe som gjør dem til C#s primære verktøy for fleksibel, løst koblet design og løsningen på begrensninger ved enkel arv (deling av muligheter på tvers av urelaterte typer). Den viktigste fordelen er å muliggjøre **løs kobling og testbarhet**: ved å avhenge av interfaces i stedet for konkrete klasser ("programmer mot et interface"), blir kode fleksibel (bytt implementeringer) og høyt **testbar** (injiser mock-implementeringer i tester — en hovedgrunn til at interfaces blir vektlagt, da de gjør avhengighetsinjeksjon og enhetstesting praktisk). Interfaces muliggjør også **polymorfisme** (behandle ulike implementeringer enhetlig gjennom interfacetypen). Forståelse av interfaces — definere kontrakter, implementere flere, programmere mot interfaces for løs kobling og testbarhet, og vanlige .NET-interfaces (`IEnumerable`, `IDisposable`, osv.) — er viktig kunnskap for design av vedlikeholdbare, testbare C#-applikasjoner og for arbeid med rammeverket (som er bygget rundt interfaces). Ettersom interfaces ligger til grunn for avhengighetsinjeksjon, testbarhet og fleksibel arkitektur — alle kjennetegn på profesjonell C# — og vises gjennomgående i .NET, er mestring av dem kjernekunnskapen som brukes ofte og skiller godt arkitekturert, testbar C# fra tett koblet kode, og er et vanlig intervjuemne som reflekterer forståelse av gode designprinsipper.