Que sont les interfaces en C# ?

Question

Accepted Answer

Une **interface** définit un **contrat** — un ensemble de membres (méthodes, propriétés) que les classes implémentantes doivent fournir, sans implémentation (traditionnellement). Une classe peut implémenter **plusieurs** interfaces, ce qui les rend essentielles pour une conception flexible, découplée et testable en C#. ## Définition et implémentation d'une 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"; } ``` Une interface (nommée `IXxx` par convention) déclare des membres sans implémentation ; une classe qui l'implémente **doit** les fournir. (Depuis C# 8, les interfaces peuvent avoir des implémentations *par défaut*, mais le rôle de contrat est primordial.) ## Interfaces multiples (vs héritage unique) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` Une classe peut implémenter **plusieurs** interfaces (contrairement à l'héritage unique de classe) — la façon qu'a C# de partager les capacités entre types sans relation. ## Polymorphisme par interfaces (l'avantage clé) ```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 ``` ## Interfaces .NET courantes et testabilité ```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) ``` ## Pourquoi c'est important Les interfaces sont au cœur d'une bonne conception C# et sont fondamentales pour la façon dont le framework .NET et les applications C# modernes sont structurées, donc les comprendre est essentiel. Les interfaces définissent des **contrats** (ce qu'un type peut faire) sans implémentation, et une classe peut implémenter **plusieurs** interfaces — ce qui en fait l'outil principal de C# pour une conception flexible et découplée, et sa réponse aux limites de l'héritage unique (partage de capacités entre types sans relation). L'avantage le plus important est d'activer un **couplage faible et la testabilité** : en dépendant des interfaces plutôt que des classes concrètes (« programmer sur une interface »), le code devient flexible (échanger les implémentations) et hautement **testable** (injecter des implémentations fictives dans les tests — une raison majeure pour laquelle les interfaces sont mises en avant, car elles rendent l'injection de dépendances et les tests unitaires pratiques). Les interfaces activent également le **polymorphisme** (traiter différentes implémentations uniformément via le type d'interface). Comprendre les interfaces — définir des contrats, implémenter plusieurs, programmer sur des interfaces pour le découplage et la testabilité, et les interfaces .NET courantes (`IEnumerable`, `IDisposable`, etc.) — est une connaissance importante pour concevoir des applications C# maintenables et testables et pour travailler avec le framework (qui est construit autour des interfaces). Puisque les interfaces sous-tendent l'injection de dépendances, la testabilité et l'architecture flexible — tous les signes distinctifs du C# professionnel — et apparaissent partout dans .NET, les maîtriser est une connaissance fondamentale, fréquemment appliquée, qui distingue le C# bien architecturé et testable du code fortement couplé, et un sujet d'entretien courant reflétant la compréhension des bons principes de conception.