Pourquoi je devrais aller pour les interfaces en C # quand je peux implémenter les méthodes directement

Je suis conscient que c’est une question très simple, mais un intervieweur m’a demandé de manière très compliquée et j’étais impuissant 🙁

Je ne connais que la définition matérielle ou théorique d’une interface et je l’ai également implémentée dans de nombreux projets sur lesquels j’ai travaillé. Mais je ne comprends vraiment pas pourquoi et comment est-ce utile?

Je ne comprends pas non plus une chose dans l’interface. c’est à dire par exemple, nous utilisons

conn.Dispose(); en bloc enfin. Mais je ne vois pas que cette classe implémente ou hérite de la classe d’interface IDisposable ( SqlConnection ) que je veux dire. Je me demande comment je peux simplement appeler le nom de la méthode. De même, je ne comprends pas comment fonctionne la méthode Dispose car nous devons implémenter le corps de la fonction avec notre propre implémentation pour toutes les méthodes d’interface. Alors, comment les interfaces sont acceptées ou nommées en tant que contrats? Ces questions ont continué à rouler dans mon esprit jusqu’à maintenant et franchement je n’ai jamais vu de fil conducteur qui expliquerait mes questions d’une manière que je peux comprendre.

Comme d’habitude, MSDN semble très effrayant et aucune ligne n’est claire (les gens, veuillez excuser ceux qui sont dans le développement de haut niveau, je pense que tout code ou article devrait atteindre l’esprit de quiconque le voit, donc comme beaucoup d’autres le disent) n’est pas utile ).

L’interviewer a dit:

Il a 5 méthodes et il est heureux de l’implémenter directement dans la classe, mais si vous devez opter pour une classe ou une interface abstraite, laquelle choisir et pourquoi? Je lui ai répondu à toutes les questions que j’ai lues dans divers blogs en disant avantage et inconvénient à la fois de la classe abstraite et de l’interface, mais il n’est pas convaincu, il essaie de comprendre “Pourquoi l’interface” en général. “Pourquoi la classe abstraite” en général, même si je ne peux implémenter les mêmes méthodes qu’une seule fois et ne pas la changer.

Je ne vois pas où dans le net, je pourrais obtenir un article qui m’expliquerait clairement sur les interfaces et son fonctionnement. Je suis un de ces nombreux programmeurs, qui ne connaissent toujours pas les interfaces (je connais des méthodes théoriques et des méthodes que j’ai utilisées) mais je ne suis pas convaincu que je les comprenne clairement.

Les interfaces sont excellentes lorsque vous voulez créer quelque chose comme ça:

  using System; namespace MyInterfaceExample { public interface IMyLogInterface { //I want to have a especific method that I'll use in MyLogClass void WriteLog(); } public class MyClass:IMyLogInterface { public void WriteLog() { Console.Write("MyClass was Logged"); } } public class MyOtherClass :IMyLogInterface { public void WriteLog() { Console.Write("MyOtherClass was Logged"); Console.Write("And I Logged it different, than MyClass"); } } public class MyLogClass { //I created a WriteLog method where I can pass as parameter any object that implement IMyLogInterface. public static void WriteLog(IMyLogInterface myLogObject) { myLogObject.WriteLog(); //So I can use WriteLog here. } } public class MyMainClass { public void DoSomething() { MyClass aClass = new MyClass(); MyOtherClass otherClass = new MyOtherClass(); MyLogClass.WriteLog(aClass);//MyClass can log, and have his own implementation MyLogClass.WriteLog(otherClass); //As MyOtherClass also have his own implementation on how to log. } } } 

Dans mon exemple, je pourrais être un développeur qui écrit MyLogClass , et les autres développeurs, pourraient créer ces classes, et quand ils voulaient se connecter, ils implémentent l’interface IMyLogInterface . C’est comme ils me demandaient ce qu’ils devaient implémenter pour utiliser la méthode WriteLog() dans MyLogClass . La réponse qu’ils trouveront dans l’interface.

Les interfaces sont des contrats que les exécutants doivent suivre. Les classes abstraites autorisent les contrats et les implémentations partagées – ce que les interfaces ne peuvent pas avoir. Les classes peuvent implémenter et hériter de plusieurs interfaces. Les classes ne peuvent étendre qu’une seule classe abstraite.

Pourquoi l’interface

  • Vous n’avez pas d’implémentation de code par défaut ou partagée
  • Vous voulez partager des contrats de données (services Web, SOA)
  • Vous avez différentes implémentations pour chaque implémenteur d’interface ( IDbCommand a SqlCommand et OracleCommand qui implémentent l’interface de manière spécifique )
  • Vous souhaitez prendre en charge l’inheritance multiple .

Pourquoi résumé

  • Vous avez une implémentation de code par défaut ou partagée
  • Vous voulez minimiser la duplication de code
  • Vous voulez facilement prendre en charge le versioning

L’une des raisons pour lesquelles j’utilise les interfaces est que cela augmente la flexibilité du code. Disons que nous avons une méthode qui prend un object de type class comme paramètre, tel que:

  public void DoSomething(Account account) { // Do awesome stuff here. } 

Le problème avec ceci est que le paramètre de méthode est fixé vers une implémentation d’un compte. Cela ne pose aucun problème si vous n’avez jamais besoin d’un autre type de compte. Prenez cet exemple, qui utilise plutôt une interface de compte en tant que paramètre.

 public void DoSomething(IAccount account) { // Do awesome stuff here. } 

Cette solution n’est pas orientée vers une implémentation, ce qui signifie que je peux lui passer un SuperSavingsAccount ou un ExclusiveAccount (tous deux implémentant l’interface IAccount) et obtenir un comportement différent pour chaque compte implémenté.

En un mot – à cause du polymorphism !

Si vous “Programmez sur une interface, pas une implémentation”, vous pouvez injecter différents objects qui partagent la même interface (type) dans la méthode en tant qu’argument. De cette manière, votre code de méthode n’est associé à aucune implémentation d’une autre classe, ce qui signifie qu’il est toujours ouvert pour fonctionner avec les objects nouvellement créés de la même interface. (Principe d’ouverture / fermeture)

  • Examinez l’dependency injection et lisez sans hésiter les modèles de conception – éléments du logiciel orienté object réutilisable de GOF.