Maîtriser les interfaces C# : Définition, implémentation et cas d'utilisation pratiques

Les interfaces C# expliquées

Ce guide vous présente les fondamentaux des interfaces C#, montre comment les créer et les implémenter, et met en lumière des scénarios réels où elles excellent.

Qu'est-ce qu'une interface C# ?

Une interface en C# est un contrat qui définit un ensemble de méthodes, propriétés, événements ou indexeurs sans fournir d'implémentation. Contrairement à une classe abstraite, chaque membre d'une interface est implicitement abstrait et public. C'est pourquoi les interfaces sont idéales pour définir des capacités que plusieurs classes non liées peuvent partager.

• Convention de nommage : Les interfaces sont préfixées par « I » (ex. IPolygone) pour signaler leur objectif d'un coup d'œil.
• Modificateurs d'accès : Les membres ne peuvent pas avoir de modificateurs d'accès à l'intérieur d'une interface ; ils sont toujours publics.
• Pas de champs : Les interfaces ne peuvent pas déclarer de champs.

interface IPolygone { void CalculerAire(); }

Implémentation d'une interface

Pour utiliser une interface, une classe doit l'implémenter en fournissant des définitions concrètes pour tous ses membres. La syntaxe deux-points (:) est utilisée, comme pour l'héritage.

using System;
namespace CsharpInterface {
    interface IPolygone {
        void CalculerAire(int longueur, int largeur);
    }
    class Rectangle : IPolygone {
        public void CalculerAire(int longueur, int largeur) {
            int aire = longueur * largeur;
            Console.WriteLine($"Aire du rectangle : {aire}");
        }
    }
    class Program {
        static void Main(string[] args) {
            Rectangle rect = new Rectangle();
            rect.CalculerAire(100, 200);
        }
    }
}

Sortie

Aire du rectangle : 20000

Implémentation de plusieurs interfaces

C# permet à une classe d'implémenter plusieurs interfaces simultanément, permettant l'héritage multiple de types.

using System;
namespace CsharpInterface {
    interface IPolygone {
        void CalculerAire(int a, int b);
    }
    interface ICouleur {
        void ObtenirCouleur();
    }
    class Rectangle : IPolygone, ICouleur {
        public void CalculerAire(int a, int b) {
            int aire = a * b;
            Console.WriteLine($"Aire du rectangle : {aire}");
        }
        public void ObtenirCouleur() {
            Console.WriteLine("Rectangle rouge");
        }
    }
    class Program {
        static void Main(string[] args) {
            Rectangle r = new Rectangle();
            r.CalculerAire(100, 200);
            r.ObtenirCouleur();
        }
    }
}

Sortie

Aire du rectangle : 20000 Rectangle rouge

Utilisation d'une référence d'interface

Bien qu'on ne puisse pas instancier une interface directement, on peut déclarer une variable de ce type d'interface et lui assigner une instance de toute classe implémentant l'interface. C'est un outil puissant pour atteindre le polymorphisme.

using System;
namespace CsharpInterface {
    interface IPolygone {
        void CalculerAire(int longueur, int largeur);
    }
    class Rectangle : IPolygone {
        public void CalculerAire(int longueur, int largeur) {
            int aire = longueur * largeur;
            Console.WriteLine($"Aire du rectangle : {aire}");
        }
    }
    class Program {
        static void Main(string[] args) {
            IPolygone poly = new Rectangle();
            poly.CalculerAire(100, 200);
        }
    }
}

Sortie

Aire du rectangle : 20000

Exemple pratique : Calculs polymorphes de formes

Ci-dessous, nous définissons une interface IPolygone et deux formes concrètes qui l'implémentent. Chaque forme calcule son aire indépendamment.

using System;
namespace CsharpInterface {
    interface IPolygone {
        void CalculerAire();
    }
    class Rectangle : IPolygone {
        public void CalculerAire() {
            int longueur = 30;
            int largeur = 90;
            int aire = longueur * largeur;
            Console.WriteLine($"Aire du rectangle : {aire}");
        }
    }
    class Carre : IPolygone {
        public void CalculerAire() {
            int cote = 30;
            int aire = cote * cote;
            Console.WriteLine($"Aire du carré : {aire}");
        }
    }
    class Program {
        static void Main(string[] args) {
            Rectangle rect = new Rectangle();
            rect.CalculerAire();
            Carre sq = new Carre();
            sq.CalculerAire();
        }
    }
}

Sortie

Aire du rectangle : 2700 Aire du carré : 900

Pourquoi utiliser les interfaces C# ?

• Abstraction : Elles définissent un contrat sans prescrire d'implémentation, permettant aux développeurs de se concentrer sur ce que une classe doit faire plutôt que comment.
• Spécification : Toute classe implémentant une interface est garantie de fournir les méthodes déclarées, assurant la cohérence dans la base de code.
• Héritage multiple : Puisque C# ne supporte pas l'héritage multiple de classes, les interfaces comblent cette lacune en permettant à une classe d'adopter plusieurs capacités.
• Faible couplage : Le code qui dépend d'une interface plutôt que d'une classe concrète est plus flexible et plus facile à maintenir ou tester.