Hvad er interfaces i C#?

Question

Accepted Answer

Et **interface** definerer en **kontrakt** — et sæt af medlemmer (metoder, egenskaber), som implementerende klasser skal tilbyde, uden implementering (traditionelt). En klasse kan implementere **flere** interfaces, hvilket gør dem vigtige for fleksibel, løst koblet og testbar design i C#. ## Definering og implementering af 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 (navngivet `IXxx` efter konvention) erklærer medlemmer uden implementering; en klasse, der implementerer det, **skal** tilbyde dem. (Siden C# 8 kan interfaces have *standardimplementeringer*, men kontraktrollen er primær.) ## Flere interfaces (vs. enkelt nedarvning) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` En klasse kan implementere **mange** interfaces (i modsætning til enkelt klasse-nedarvning) — C#'s måde at dele funktionalitet på tværs af urelaterede typer. ## Polymorfi gennem 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 ``` ## Almindelige .NET-interfaces og testbarhed ```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 betyder noget Interfaces er centrale for god C#-design og er grundlæggende for, hvordan .NET-framework'et og moderne C#-applikationer er struktureret, så forståelse af dem er vigtig. Interfaces definerer **kontrakter** (hvad en type kan gøre) uden implementering, og en klasse kan implementere **flere** interfaces — hvilket gør dem til C#'s primære værktøj for fleksibel, løst koblet design og svaret på begrænsninger ved enkelt-nedarvning (deling af funktionalitet på tværs af urelaterede typer). Den vigtigste fordel er at muliggøre **løs kobling og testbarhed**: ved at være afhængig af interfaces i stedet for konkrete klasser ("programnær til et interface"), bliver koden fleksibel (swap implementeringer) og meget **testbar** (indsæt mock-implementeringer i tests — en vigtig grund til, at interfaces er fremhævet, da de gør dependency injection og unit testing praktisk). Interfaces muliggør også **polymorfi** (behandling af forskellige implementeringer ensartet gennem interface-typen). Forståelse af interfaces — definition af kontrakter, implementering af flere, programmering mod interfaces for løs kobling og testbarhed, og almindelige .NET-interfaces (`IEnumerable`, `IDisposable` osv.) — er vigtig viden for design af vedligeholdelig, testbar C#-applikationer og for arbejde med framework'et (som er bygget omkring interfaces). Da interfaces understøtter dependency injection, testbarhed og fleksibel arkitektur — alle kendetegn ved professionel C# — og optræder gennem hele .NET, er at mestre dem kernevet viden, der hyppigt anvendes, som adskiller veltilrettelagt, testbar C# fra tæt koblet kode, og er et almindeligt interviewemne, der afspejler forståelse af gode designprincipper.