Démystifier les interfaces C# avec des exemples pratiques

Les interfaces constituent un concept C# intégral permettant des architectures logicielles flexibles. Cependant, certains développeurs trouvent les interfaces déroutantes ou ont du mal à les utiliser efficacement. Dans ce guide complet, nous démystifierons les interfaces C# à l’aide d’exemples pratiques et d’exemples de code.

Qu’est-ce qu’une interface en C# ?

Commençons par les bases – une interface déclare un contrat spécifiant :

• Propriétés
• Méthodes
• Événements

Les classes, structures et autres types peuvent alorsmettre en œuvreinterfaces pour obtenir la fonctionnalité définie.

Une interface C# définit des fonctionnalités communes que les classes d'implémentation garantissent de fournir

Voici un exemple d'interface simple en C# :

public interface ILogger {
    void Log(string message); 
}

Cette interface ILogger a un membre : unLogméthode qui accepte un message texte.

Toute classe implémentantILoggerdoit réellement fournir leLogfonctionnalité de la méthode. Les interfaces déclarent uniquement les membres – elles ne fournissent pas d’implémentations.

Explorons maintenant quelques avantages clés que les interfaces permettent…

Pourquoi les interfaces C# sont-elles utiles ?

1. Couplage lâche

Les interfaces permettentaccouplement lâcheentre les classes en faisant abstraction des détails d’implémentation.

Considérez cette utilisation de l'interface :

public interface ILogger {
    void Log(string message);
}

public class EmailLogger : ILogger {
    public void Log(string message) {
        // email log logic
    }
}

public class DatabaseLogger : ILogger {
    public void Log(string message) {
       // database logic 
    }
}

// Application code
ILogger logger = GetLogger(); 
logger.Log("Application starting");

Le code de l'application utilise simplement l'interface ILogger pour se connecter. Il ne sait pas ou ne se soucie pas de savoir si un EmailLogger ou un DatabaseLogger est transmis au moment de l'exécution.

Ce couplage lâche rend l'application plusflexible et maintenable dans le temps. Par exemple, nous pourrions ajouter de nouveaux types d'enregistreurs sans modifier le code de l'application.

2. Abstraction

Les interfaces fournissent une abstraction en séparant les fonctionnalités logiques des implémentations spécifiques.

Le code utilisant des interfaces se concentre surquoidont il a besoin – en vous connectant dans l’exemple ci-dessus. Gestion des classes d'implémentationcommentcette fonctionnalité est réellement réalisée en fonction de besoins différents.

Cela permet d'échanger des implémentations sans affecter la consommation de code.

3. Polymorphisme

Une variable déclarée comme type d'interface peut faire référence à n'importe quel objet qui implémente cette interface. Ce polymorphisme est puissant :

public interface IShape {
    void Draw();
}

public class Circle : IShape {
   // draw circle 
}

public class Square : IShape {
    // draw square
}

// Application code
public void Render(IShape shape) {
    shape.Draw(); // polymorphic call
}

Render(new Circle()); // draw circle
Render(new Square()); // draw square

Malgré les différents objets sous-jacents, l'application peut s'interfacer à la fois avec des cercles et des carrés via IShape, permettant un comportement dynamique et polymorphe.

Cela permet une grande flexibilité : le code d’application existant fonctionne avec tous les nouveaux types qui implémentent les interfaces sur lesquelles il s’appuie sans nécessiter de modification. Permet d'étendre les implémentations sans modifier le code consommateur.

4. Héritage multiple

Contrairement aux classes, les interfaces C# peuvent être implémentées par des classes en plus d'hériter d'une classe de base.

interface I1 {}
interface I2 {}

abstract class Base {}

class MyClass : Base, I1, I2 {}

Cela combine les fonctionnalités héritées deBaseavecI1etI2interfaces prises en charge simultanément. Technique très puissante !

Maintenant que nous avons couvert les principaux avantages offerts par les interfaces, passons en revue quelques bonnes pratiques…

Implémentation efficace des interfaces

Même si les interfaces peuvent sembler simples au départ, il existe quelques bonnes pratiques à prendre en compte :

Privilégiez les interfaces petites et ciblées

Ne le faites pascréer des interfaces massives en essayant de généraliser de nombreuses fonctionnalités. Au lieu de cela, créez de petites interfaces ciblées avec des responsabilités claires :

MAUVAIS

public interface IShape {
    void Draw();
    string GetName();
    void ComputeArea(); 
    // etc...
}

BIEN

public interface IRenderable {
    void Draw();
}

public interface INamed {
    string GetName();    
}

public interface IMeasurable {
   double ComputeArea();
}

Les petits ensembles de membres étroitement liés sont préférables – ils peuvent ensuite être combinés via l’héritage d’interface.

Utilisez des noms significatifs

Les interfaces représentent des concepts et doivent donc avoir des noms descriptifs et révélateurs d'intention commeIComparable,IEquatable, etc.

MAUVAIS

public interface IX {}

BIEN

public interface ILoggable {
    void Log(); 
}

Conception pour l'extensibilité

Lors de la création d'interfaces largement utilisées, envisagez une extensibilité ultérieure :

public interface ILogger {
    void Log(string message);

    // Good - leaves room for extraction without breaking changes
    void Log(LogEntry entry); 
}

La deuxièmeLogLa méthode laisse de la flexibilité si la journalisation nécessite plus de structure à l'avenir. Les implémentations existantes ignorent les membres les plus récents.

Planifiez à l’avance le cas échéant pour permettre l’ajout de membres sans causer de problèmes. Cela facilite l’amélioration itérative.

Utilisation de l'interface du monde réel

Examinons certaines utilisations de l'interface à partir de scénarios courants du monde réel :

Accès à la base de données

ADO.NET utilise des interfaces permettant d'échanger des fournisseurs de bases de données :

// Common IDbConnection interface
IDbConnection connection = new SqlConnection(...);

IDbConnection connection = new OracleConnection(...);

Résumés sous-jacents à la mise en œuvre de la base de données.

Injection de dépendances ASP.NET Core

ASP.NET Core exploite largement les interfaces pour l’injection et le découplage des dépendances :

// Interface for email sender
public interface IEmailSender {
    void SendEmail(Message message);
}

// Startup configuration 

public void ConfigureServices(IServiceCollection services) {
    // ...
    services.AddTransient<IEmailSender, SendGridEmailSender>();
    // ...
}

// Controller uses interface
public class ContactController {

    private readonly IEmailSender emailSender;   

    public ContactController(IEmailSender email) {
        emailSender = email;
    }

    public async Task Contact(Message message) {
         await emailSender.SendEmail(message);
    }
}

Permet de changer de fournisseur de messagerie sans changer de contrôleur. Implémentation des résumés d'interface.

Se moquer des tests unitaires

Dans les tests unitaires, les interfaces permettent d'injecter des implémentations fictives pour isoler les classes testées :

public interface IOrderProcessor {
    void ProcessOrder(Order order);
}

public class OrderController {

    private readonly IOrderProcessor processor;  

    public OrderController(IOrderProcessor processor) {
        this.processor = processor;
    }

    public void SubmitOrder(Order order) { 
        processor.ProcessOrder(order);
    }

}

// Testing 

var mockProcessor = new Mock<IOrderProcessor>(); 

var controller = new OrderController(mockProcessor.Object);

controller.SubmitOrder(testOrder);

mockProcessor.Verify(...);

Les interfaces permettent une moquerie efficace pour obtenir un isolement sans effets secondaires.

Prise en charge multiplateforme

API courantes telles que les interfaces cibles .NET Standard permettant la prise en charge sur toutes les plates-formes :

// .NET Standard 
public interface ILogger {
    void Log(LogEntry entry);
}

// Concrete implementation assemblies per platform
class NetFrameworkLogger : ILogger {...}
class LinuxLogger : ILogger {...} 

Simplifie la fourniture d'implémentations optimisées pour chaque plate-forme.

Comme vous pouvez le constater, les interfaces alimentent de nombreuses fonctionnalités clés : du polymorphisme à la DI, en passant par la simulation et le code multiplateforme. Comprendre les bonnes pratiques des interfaces permet de tirer pleinement parti de leurs atouts.

Points clés à retenir sur les interfaces C#

Récapitulons les interfaces :

• Les interfaces déclarent des contrats de membre pour implémenter des types
• Activer le couplage lâche grâce à l'abstraction
• Autoriser la substitution polymorphe des implémentations
• Doit être petit, ciblé et extensible
• Largement utilisé pour les tests, l'injection de dépendances, les bases de données et les abstractions de plateforme

J'espère que ce guide vous a aidé à expliquer les interfaces et comment les appliquer efficacement. N'hésitez pas à nous contacter pour toute autre question !