2009-11-13 6 views
5

En supposant que je veuille utiliser une infrastructure d'injection de dépendance dans une approche AOP, avec l'objectif de produire des modules de code. Quelle est la meilleure pratique pour la propriété des interfaces partagées? Par propriété, je veux dire le corps de code qui doit être référencé pour utiliser l'interface. Ma première supposition est que dans AOP vous définissez une bibliothèque de classes d'interfaces, namespaced par aspect. Par exemple: company.aspect.logging.ILogger. Chaque module référencerait alors cette bibliothèque et éviterait que tout code impliqué dans l'implémentation d'ILogger définisse aussi ILogger.Injection de dépendances - Qui possède l'interface?

Meilleures pratiques?

+0

C'est exactement ce que je ferais (ayant des interfaces dans une classe séparée qui ne contient que des interfaces). – Tomas

Répondre

1

Définir une bibliothèque de classes d'interfaces est un bon début. Cela vous donne le maximum de flexibilité, car vous pouvez faire varier tous les consommateurs et tous les exécutants complètement indépendamment les uns des autres.

L'inconvénient de cette approche est que si vos interfaces elles-mêmes à l'exportation d'autres interfaces comme celle-ci:

public interface IMyInterface 
{ 
    IMyOtherInterface DoStuff(); 
} 

vous devrez peut-être écrire beaucoup de code de mappage qui peuvent remplir des classes concrètes à partir des interfaces (ou vous pouvez utiliser AutoMapper).

Si vous avez seulement un consommateur mais plusieurs impulseurs, vous pouvez vous épargner une partie de ce mappage en définissant les interfaces avec le consommateur (jamais avec l'implémenteur), mais vous perdez une partie de la flexibilité. Cependant, vous pouvez toujours faire varier les implémenteurs indépendamment du consommateur, mais pas l'inverse.

+0

Je pense qu'un framework d'injection de dépendances prendrait en charge une bonne partie du code de mappage, en prenant l'exemple de Guice de Google. Un grand merci pour l'introduction à AutoMapper. Ma première idée pour cet outil par rapport à ma question serait: 1 - définir des interfaces avec l'implémentation 2 - utiliser AutoMapper pour construire une couche d'adaptateur Réalisant ainsi l'encapsulation et la prise en charge de modules tiers. Juste rêver ... –

0

Il dépend de l'objectif de l'interface:

Si le but de l'interface est de définir un protocole standard entre un ensemble de fournisseurs alternatifs et un seul consommateur, l'interface est détenue par le consommateur.

Si le but de l'interface est définir un protocole standard entre un fournisseur unique et un ensemble de consommateurs alternatifs, l'interface est la propriété du fournisseur. Si le but de l'interface est définir un protocole standard entre un ensemble de fournisseurs alternatifs et un ensemble de consommateurs alternatifs, l'interface est autonome. Enfin, si les interfaces sont utilisées comme approche générale pour réduire la complexité, elles sont généralement détenues par les consommateurs et doivent être définies aussi étroitement que possible de sorte que chaque interface prenne en charge les besoins du consommateur dans un contexte de besoins spécifiques.