Qu’est-ce que la «programmation basée sur une interface»?

J’entends souvent / lis beaucoup de choses sur la programmation basée sur les interfaces, mais je ne comprends pas très bien ce que cela signifie. La programmation basée sur les interfaces est-elle un sujet autonome à part entière dans lequel des livres ont déjà été écrits? Si oui, quelqu’un peut-il en recommander de bons?

Je suis tombé sur une programmation basée sur une interface alors que je lisais sur la manière dont les API sont conçues et souhaite en apprendre davantage à ce sujet. À l’heure actuelle, je ne vois pas comment concevoir correctement une API autour d’interfaces.

Toute info est grandement appréciée.

Il s’agit essentiellement d’exprimer vos dépendances en termes d’interfaces plutôt que de classes concrètes (ou pire, de méthodes statiques). Ainsi, si l’une de vos classes doit effectuer une authentification, vous devez lui fournir un IAuthenticator (ou autre).

Cela signifie que:

  • Vous pouvez écrire votre code avant d’implémenter la dépendance réelle
  • Vous pouvez tester très facilement en vous moquant (sans avoir à vous moquer des cours, qui deviennent laids)
  • Il est clair que vous dépendez de l’API plutôt que de la mise en œuvre (par exemple, vous avez un couplage plus lâche)

Le chapitre 6 de “Practical API Design” de Jaroslav Tulach est intitulé “Code contre interfaces, pas mises en oeuvre”. Il explique qu’en codant sur une interface plutôt que sur une implémentation spécifique, vous pouvez découpler des modules (ou composants) dans un système et ainsi améliorer la qualité du système.

Bertrand Meyer dans OOSC2 explique clairement pourquoi “fermer” un système et le rendre plus modulaire en augmente la qualité.

Voyez si ces discussions très populaires vous aident:

Quelle est la meilleure analogie pour aider la programmation basée sur l’interface avec les développeurs non-oop?

Pourquoi voudrais-je utiliser des interfaces?

Quand faut-il des interfaces?

Quand faut-il utiliser des interfaces?

Quel est le but des interfaces?

Bon cas pour les interfaces

Qu’est-ce que cela signifie “programmer pour une interface”?

Si vous recherchez des interfaces sur Google, vous trouverez de nombreuses informations sur l’utilité des interfaces.

Le concept consiste à définir des interfaces claires, qui seront utilisées par les différents composants / pièces / classes / modules pour communiquer et interagir. Une fois que vous avez défini l’entrée / la sortie de ces interfaces, vous pouvez laisser les différentes équipes développer ce qui est nécessaire pour répondre aux exigences de l’interface, y compris les tests d’entrée / sortie, etc.

Si vous suivez ce schéma, différentes équipes peuvent commencer à développer leur partie sans attendre que les autres parties soient prêtes. De plus, vous pouvez utiliser les tests unitaires (en utilisant de faux objects pour simuler les autres parties que vous ne développez pas et tester votre partie).

Cette méthode est tout à fait la norme pour tout nouveau projet de programmation et tout le monde le prendra pour acquis.

Ce que vous appelez “programmation basée sur une interface” est plus communément appelé programmation sur une interface. Voici un exemple ci-dessous. L’avantage cache la mise en œuvre réelle de l’interface et permet à votre code d’être plus flexible et facile à gérer à l’avenir.

 YourInterface foo = CreateYourInterface(); foo.DoWork(); foo.DoMoreWork(); 

CreateYourInterface () renverrait une implémentation concrète de YourInterface. Cela vous permet de modifier les fonctionnalités de l’application en modifiant une ligne:

 YourInterface foo = CreateYourInterface(); 

C’est quelque chose que je ne recommande pas d’utiliser fortement dans le développement C #.

La programmation par interface consiste essentiellement à programmer des interfaces. Vous développez les interfaces pour lesquelles vous allez utiliser un contrat, et la mise en œuvre réelle des interfaces est cachée derrière ces contrats.

C’était très courant avant .NET, car le meilleur moyen d’obtenir des composants réutilisables dans Windows était via COM, qui fonctionnait via des interfaces partout. Cependant, étant donné que .NET est capable de prendre en charge plusieurs langues avec un seul runtime (le CLR), ainsi que son support supérieur pour la gestion des versions par rapport au code natif, l’utilité de la programmation par interface est considérablement réduite lorsque vous programmez en C # ( sauf si vous essayez de créer des composants COM, auquel cas vous créerez toujours les interfaces COM indirectement à partir de vos classes C #).

La programmation par interface peut être considérée comme un découplage de la mise en œuvre de la fonctionnalité et de la manière dont vous accédez à la fonctionnalité.

Vous définissez une interface
interface ICallSomeone { public bool DialNumber(ssortingng number); }

et vous écrivez votre mise en œuvre

public class callsomeone: ICallSomeone {
public bool DialNumber(ssortingng number) {
//dial number, return results }}

Vous utilisez l’interface sans vous soucier de l’implémentation. Si vous modifiez l’implémentation, rien ne le dérange car il utilise uniquement l’interface.

D’un sharepoint vue très abstrait, la programmation par interface s’apparente aux composants utilisés par un plombier (raccords et tuyaux).

Tant que les tuyaux et les joints sont fabriqués conformément à l’interface spécifiée (nombre de filets et espacement, etc.), divers fabricants peuvent assembler des tuyaux pouvant être fabriqués par un autre fournisseur (mais adhérant au interface).

Ainsi, l’interopérabilité des composants et la liberté dont dispose le plombier pour choisir entre différents fournisseurs, gammes de prix, etc. afin de créer un système de plomberie fonctionnel.

Remplacez les tuyaux et les joints par des composants logiciels et les parallèles sont étonnamment simples.