Parcours
/
C#
C#
/
Programme
/
Interfaces
In

Interfaces en C#

2 exercices

À propos de Interfaces

interfaces sont le principal moyen de découpler les utilisations d'une classe de son implémentation. Ce découplage apporte de la souplesse pour la maintenance de l'implémentation et aide à prendre en charge un comportement générique sûr du point de vue du typage.

La syntaxe d'une interface est semblable à celle d'une classe ou d'un struct, à la différence près que les méthodes et les propriétés n'apparaissent que sous forme de signature et qu'aucun corps n'est fourni.

public interface ILanguage
{
    string Speak();
}

public interface IItalianLanguage : ILanguage
{
    string Speak();
    string SpeakItalian();
}

public interface IScriptConverter
{
    string Version { get; set; }
    string ConvertCyrillicToLatin(string cyrillic);
}

La classe ou le struct qui implémente l'interface doit implémenter toutes les opérations définies par l'interface.

Les interfaces font généralement une ou plusieurs des choses suivantes :

  • permettre au code appelant de traiter de manière générique plusieurs classes différentes. Dans ce cas, les interfaces jouent le même rôle qu'une classe de base ;
  • exposer un sous-ensemble de fonctionnalités dans un but précis (comme IComparable<T>) ;
  • exposer l'API publique d'une classe pour que plusieurs implémentations puissent coexister. Le test double en est un exemple.
public class ItalianTraveller : IItalianLanguage
{
    public string Speak()
    {
        return "Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class ItalianTravellerV2 : IItalianLanguage
{
    public string Speak()
    {
        return "migliorata - Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class FrenchTraveller : ILanguage
{
    public string Speak()
    {
        return "Ça va?";
    }
}

public class RussianTraveller : ILanguage, IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Speak()
    {
        return "Привет мир";
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

public class DocumentTranslator : IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Translate(string russian)
    {
        throw new NotImplementedException();
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

Le code qui utilise les interfaces et les classes ci-dessus peut :

  • traiter tous les locuteurs de la même manière, quelle que soit la langue ;
  • permettre à un sous-système chargé de la conversion d'écriture de fonctionner sans se soucier des types précis qu'il manipule ;
  • rester ignorant des modifications apportées au locuteur italien, ce qui est pratique si le code des classes et le code utilisateur sont maintenus par des équipes différentes.

Les interfaces sont largement utilisées pour faciliter les tests, car elles permettent un mocking aisé.

Consulte cet article pour savoir en détail quels types de membres une interface peut contenir.

Les interfaces peuvent hériter d'autres interfaces.

Par défaut, les membres d'une interface sont publics.

Les interfaces peuvent contenir des types imbriqués, comme des littéraux const, des enums, des delegates, des classes et des structs. Ici, les interfaces jouent le rôle d'espaces de noms, de la même manière que les classes et les structs, et leur comportement comme leur syntaxe sont identiques.

Par conception, C# ne prend pas en charge l'héritage multiple, mais il facilite une forme d'héritage multiple au moyen des interfaces.

De plus, le mécanisme des interfaces repose sur le concept selon lequel le polymorphisme peut être mis en œuvre au moyen d'interfaces.

Implémentation explicite des interfaces

Il arrive que deux interfaces différentes partagent les mêmes noms de méthodes et les mêmes signatures. Pour fournir une implémentation distincte de ces méthodes, C# propose l'implémentation explicite des interfaces. Note que pour utiliser une implémentation particulière d'une interface, tu dois convertir en cette interface l'expression qui référence l'objet. Une affectation, un transtypage ou un passage en paramètre permet d'y parvenir.

public interface IFoo
{
    void X();
}

public interface IBar
{
    void X();
}

public class Census : IFoo, IBar
{
    void IFoo.X()
    {
        Console.Write("This is from Foo");
    }

    void IBar.X()
    {
        Console.Write("This is from Bar");
    }
}

public class User
{
    public void Use()
    {
        IFoo foo = new Census();
        IBar bar = new Census();
        foo.X();
        // => "This is from Foo"
        bar.X();
        // => "This is from Bar"
    }
}

Il existe plusieurs cas d'usage :

  • Un conflit de domaines (comme illustré plus haut) où les méthodes ont des signatures identiques.
  • Des méthodes portant le même nom mais renvoyant des types différents : si tu écris tes propres classes de collection, tu peux avoir besoin d'une interface explicite pour l'ancien IEnumerable.GetEnumerator(), à côté de IEnumerable<T>.GetEnuerator(). Il se peut que tu n'utilises jamais cette interface, mais le compilateur peut l'exiger.
  • Des méthodes pour lesquelles il n'y a aucun conflit de noms entre les interfaces, mais où il est souhaitable que la classe qui implémente utilise ce nom dans un but connexe : IFormattable possède une méthode ToString() qui prend un paramètre format type ainsi qu'un paramètre de type IFormatProvider. Une classe comme FormattableString de la bibliothèque de classes de base (BCL) implémente l'interface pour pouvoir être utilisée par des routines qui prennent un IFormattable, mais il est plus expressif que sa version principale de ToString(IFormatProvider) omette le paramètre format type, car il n'est pas utilisé dans l'implémentation et ne ferait que désorienter les utilisateurs de l'API.

Implémentation par défaut

La version 8 de C# répond à un problème lancinant des API. Si tu ajoutes des méthodes à une interface pour enrichir les fonctionnalités destinées aux nouvelles implémentations, il faut alors modifier toutes les implémentations existantes de l'interface pour qu'elles respectent le contrat de l'API, même si elles n'ont aucun comportement propre à implémenter. C# permet désormais de fournir une méthode par défaut directement dans l'interface (les développeurs Java connaissent bien ce principe). Auparavant, quand un tel changement survenait, une version 2 de l'interface venait s'ajouter à l'originale.

Cet article est une excellente introduction aux interfaces ; il traite en particulier de l'implémentation par défaut et d'autres nouveautés associées, comme les membres static, private et virtual.

Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet

Apprends Interfaces

L'entraînement est verrouillé

Déverrouille 1 exercice de plus pour t'entraîner sur Interfaces