implémentation implicite vs interface explicite

Duplication possible:
C #: Interfaces – Implémentation implicite et explicite

Quelqu’un pourrait-il expliquer les différences entre ces deux bêtes et comment les utiliser. AFAIK, de nombreuses classes pre.2.0 ont été implémentées sans types génériques, ce qui a amené la dernière version à implémenter les deux types d’interfaces. Est-ce le seul cas pour lequel il faudrait les utiliser?

Pouvez-vous également expliquer en détail comment les utiliser?

Merci

Il y a un bon article de blog assez détaillé à ce sujet.

Fondamentalement, avec l’implémentation d’interface implicite, vous accédez aux méthodes et propriétés d’interface comme si elles faisaient partie de la classe. Avec les implémentations d’interface explicites, vous ne pouvez y accéder que si vous l’utilisez comme interface.

En ce qui concerne l’utilisation de l’une sur l’autre, vous devez parfois utiliser une implémentation d’interface explicite car vous avez une propriété / méthode avec la même signature que l’interface ou vous souhaitez implémenter deux interfaces avec les mêmes signatures et des implémentations différentes pour les propriétés / méthodes qui correspondent.

Les règles ci-dessous sont tirées du blog des directives de conception de Brad Abrams.

  • N’utilisez pas de membres explicites comme limite de sécurité. Ils peuvent être appelés par n’importe quel client qui lance une instance sur l’interface.
  • Utilisez des membres explicites pour masquer les détails d’implémentation
  • Utilisez des membres explicites pour s’approcher des implémentations d’interfaces privées.
  • Exposez une autre manière d’accéder aux membres explicitement implémentés que les sous-classes sont autorisées à remplacer. Utilisez le même nom de méthode à moins qu’un conflit ne se produise.

Il est également mentionné dans les commentaires du blog de Brad qu’il ya de la boxe lorsqu’on utilise une implémentation explicite sur des types de valeur, alors soyez conscient du coût des performances.

En termes simples, si une classe hérite de 2 interfaces ou plus et que les interfaces possèdent les mêmes noms de méthode, la classe ne sait pas quelle méthode d’interface est implémentée si vous utilisez l’implémentation d’interface implicite. Ceci est l’un des scénarios lorsque vous implémentez explicitement une interface.

Implémentation d’interface implicite

public class MyClass : InterfaceOne, InterfaceTwo { public void InterfaceMethod() { Console.WriteLine("Which interface method is this?"); } } interface InterfaceOne { void InterfaceMethod(); } interface InterfaceTwo { void InterfaceMethod(); } 

Mise en œuvre d’interface explicite

 public class MyClass : InterfaceOne, InterfaceTwo { void InterfaceOne.InterfaceMethod() { Console.WriteLine("Which interface method is this?"); } void InterfaceTwo.InterfaceMethod() { Console.WriteLine("Which interface method is this?"); } } interface InterfaceOne { void InterfaceMethod(); } interface InterfaceTwo { void InterfaceMethod(); } 

Le lien suivant contient une excellente vidéo expliquant ce concept
Mise en œuvre d’interface explicite

Il y a une autre façon de regarder, de l’implémentation labyrinthique elle-même, ici: http://blogs.msdn.com/cbrumme/archive/2003/05/03/51381.aspx .

En bref, l’implémentation implicite vous donne une conversion de type is-a, l’implémentation explicite ne sera accessible que si l’object est explicitement transtypé sur ce type d’interface.