Was sind Interfaces in C#?

Question

Accepted Answer

Ein **Interface** definiert einen **Vertrag** — eine Menge von Members (Methoden, Eigenschaften), die implementierende Klassen bereitstellen müssen, traditionell ohne Implementierung. Eine Klasse kann **mehrere** Interfaces implementieren, was sie zu einem Schlüssel für flexibles, entkoppeltes und testbares Design in C# macht. ## Definieren und Implementieren eines Interfaces ```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"; } ``` Ein Interface (nach Konvention benannt als `IXxx`) deklariert Members ohne Implementierung; eine Klasse, die es implementiert, **muss** diese bereitstellen. (Seit C# 8 können Interfaces *Standard*-Implementierungen haben, aber die Vertragsrolle ist primär.) ## Mehrere Interfaces (vs. Einfachvererbung) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` Eine Klasse kann **viele** Interfaces implementieren (anders als Einfachvererbung bei Klassen) — C#s Art, Fähigkeiten über unverwandte Typen hinweg zu teilen. ## Polymorphismus durch Interfaces (der Schlüsselbenefit) ```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 ``` ## Häufige .NET-Interfaces und Testbarkeit ```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) ``` ## Warum es wichtig ist Interfaces sind zentral für gutes C#-Design und fundamental dafür, wie das .NET-Framework und moderne C#-Anwendungen strukturiert sind, daher ist das Verständnis dafür unerlässlich. Interfaces definieren **Verträge** (was ein Typ tun kann) ohne Implementierung, und eine Klasse kann **mehrere** Interfaces implementieren — was sie zu C#s primärem Werkzeug für flexibles, entkoppeltes Design macht und die Antwort auf Einfachvererbungslimitierungen darstellt (Fähigkeiten über unverwandte Typen teilen). Der wichtigste Nutzen ist die Ermöglichung von **loser Kopplung und Testbarkeit**: Durch Abhängigkeit von Interfaces statt konkreten Klassen ("gegen ein Interface programmieren") wird Code flexibel (Implementierungen austauschbar) und stark **testbar** (Mock-Implementierungen in Tests einfügen — ein Hauptgrund, warum Interfaces betont werden, da sie Dependency Injection und Unit Testing praktisch machen). Interfaces ermöglichen auch **Polymorphismus** (verschiedene Implementierungen einheitlich über den Interface-Typ behandeln). Interfaces verstehen — Verträge definieren, mehrere implementieren, gegen Interfaces für Entkopplung und Testbarkeit programmieren, und die häufigen .NET-Interfaces kennen (`IEnumerable`, `IDisposable` usw.) — ist wichtiges Wissen für die Gestaltung wartbarer, testbarer C#-Anwendungen und für die Arbeit mit dem Framework (das um Interfaces aufgebaut ist). Da Interfaces Dependency Injection, Testbarkeit und flexible Architektur zugrunde liegen — alle Merkmale professionellen C# — und überall in .NET vorkommen, ist ihre Beherrschung Kernwissen, das häufig angewendet wird und professionell architekturiertes, testbares C# von eng gekoppeltem Code unterscheidet, und ein häufiges Interviewthema, das das Verständnis guter Designprinzipien widerspiegelt.