Maîtriser les interfaces C# : contrats de conception pour une POO robuste

Une interface est un contrat syntaxique que toutes les classes l'héritant doivent suivre. Elle définit le "quoi" (quelles méthodes/propriétés), la classe dérivée définit le "comment" (implémentation).

Les interfaces déclarent propriétés, méthodes, événements. Elles ne contiennent que les déclarations. La classe dérivée implémente les membres.

Les classes abstraites servent un but similaire, mais sont utilisées quand peu de méthodes sont déclarées par la classe de base.

Déclaration d'une interface

Mot-clé interface. Membres publics par défaut.

public interface ITransactions
{
    void AfficherTransaction();
    double ObtenirMontant();
}

Exemple d'implémentation

using System;

namespace ApplicationInterface
{
    public interface ITransactions
    {
        void AfficherTransaction();
        double ObtenirMontant();
    }
    
    public class Transaction : ITransactions
    {
        private string code;
        private string date;
        private double montant;
        
        public Transaction() { code = " "; date = " "; montant = 0.0; }
        public Transaction(string c, string d, double a) { code = c; date = d; montant = a; }
        
        public double ObtenirMontant() { return montant; }
        
        public void AfficherTransaction()
        {
            Console.WriteLine("Transaction : {0}", code);
            Console.WriteLine("Date : {0}", date);
            Console.WriteLine("Montant : {0}", ObtenirMontant());
        }
    }
    
    class Test
    {
        static void Main(string[] args)
        {
            Transaction t1 = new Transaction("001", "8/10/2012", 78900.00);
            Transaction t2 = new Transaction("002", "9/10/2012", 451900.00);
            t1.AfficherTransaction();
            t2.AfficherTransaction();
            Console.ReadKey();
        }
    }
}

Résultat :

Transaction : 001
Date : 8/10/2012
Montant : 78900
Transaction : 002
Date : 9/10/2012
Montant : 451900

Points clés

• Une classe peut implémenter plusieurs interfaces
• Une interface peut hériter d'autres interfaces
• Implémentation explicite possible : void ITransactions.AfficherTransaction() { ... }
• Membres d'interface implicitement public (pas de modificateur d'accès)
• Depuis C# 8.0 : méthodes par défaut dans interfaces