Découvrir l'implémentation explicite des interfaces en C# (partie 4),

Un tutoriel de François DORIN

Le 26/08/2018, par François DORIN, Expert éminent sénior

Ce billet s'inscrit dans une série de billets autour de l'implémentation explicite des interfaces en C#.

Dans le premier billet, nous avons vu qu'il existe deux manières d'implémenter une interface en C#. De manière implicite (la voie "classique") et de manière explicite. Le billet était illustré par un exemple d'utilisation, avec la "surcharge" d'une méthode en modifiant uniquement son type de retour.

Dans le second billet, nous avons abordé un autre de ces cas d'usage : le masquage d'une méthode.

Dans le troisième billet, nous avons étudié une autre utilisation possible : implémenter des interfaces définissant les mêmes méthodes, mais avec des sémantiques différentes.

Dans ce quatrième billet, nous allons aborder les propriétés et les événements.

Membres d'une interface
Au cours des précédents billets, nous avons abordé uniquement l'implémentation explicite de méthodes spécifiées par une interface. Mais une interface, ce n'est pas uniquement des méthodes, c'est aussi des propriétés et des événements. Nous allons donc voir comment implémenter explicitement cela.

Les propriétés

Comme il s'agit principalement d'un aspect syntaxique, commençons directement par un exemple de code :

Code C# :

1
2
3
4
5
6
7
8
9
10
    public interface IMonInterface 
    { 
        string UnePropriete { get; set; } 
    } 
  
    public class InterfaceExplicite : IMonInterface 
    { 
        // Implémentation explicite d'une propriété 
        string IMonInterface.UnePropriete { get; set; } 
    }

Est-il vraiment besoin d'approfondir l'implémentation explicite d'une propriété d'une interface ? Cela se fait de la même manière que pour une méthode :

la visibilité n'est pas précisée (pas de public) ;
le nom de la propriété est précédée du nom de l'interface.

Les événements
L'implémentation explicite d'un événement est un moins intuitif. En effet, nous sommes obligés ici d'écrire explicitement les méthodes add et remove associées à l'événement en question :

Code C# :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    public interface IMonInterface 
    { 
        event EventHandler UnEvenement; 
    } 
  
    public class InterfaceExplicite : IMonInterface 
    { 
        // Implémentation explicite d'un événement 
        private EventHandler handler; 
  
        event EventHandler IMonInterface.UnEvenement 
        { 
            add { handler += value; } 
            remove { handler -= value; } 
        } 
    }

Il n'est pas possible d'implémenter automatiquement un événement explicite (chose possible avec un une implémentation implicite d'un événement). Autrement dit, la syntaxe suivante n'est pas supportée :

Code C# :

event EventHandler IMonInterface.UnEvenement;

alors que pour une implémentation implicite, celle-ci l'est :

Code C# :

public event EventHandler UnEvenement;

Pour le reste, c'est la même chose que pour les propriétés ou les méthodes : la visibilité n'est pas précisée, et le nom de l'événement est précédé par le nom de l'interface.

Conclusion
Voilà, maintenant, nous savons comment implémenter explicitement n'importe quel membre d'une interface, que ce soit une méthode, une propriété ou un événement.

L'implémentation explicite suit la même logique, quelque soit le type de membre. Seul l'implémentation des événements est un peu plus complexe dans la mesure où il est obligatoire de procéder à une implémentation complète.

Billet blog