Je sais que les interfaces ne peuvent pas définir les constructeurs. Quelle est la meilleure pratique pour forcer toutes les classes à mettre en œuvre une interface, à recevoir leurs dépendances dans un contrat uniforme. Je sais que l'INTS est possible d'injecter des dépendances dans des objets via des propriétés, mais les transmettre via des constructeurs a plus de sens pour moi. Comment di tant?
5 Réponses :
Une option est de créer une méthode sur l'interface pour l'initialisation. Cette méthode peut accepter toutes les dépendances requises.
Quelque chose comme: Bien sûr, il y a beaucoup d'options pour faire ce type d'initialisation et DI en utilisant un cadre. Cependant, il y a beaucoup d'options à choisir. Scott Hanselman a une bonne liste Ici .
Ce que vous devez faire est d'avoir toutes vos implémentations d'interface sous-classe une classe avec un constructeur qui prend l'état qui doit être injecté. Étant donné que les sous-classes doivent effectuer un appel de base, dans leur constructeur, vos contraintes sont défendues automatiquement.
Au début, cela peut sembler un modèle étrange, mais nous l'utilisons tout le temps de nos solutions d'entreprise, donc je vous garantis sur SANE: -)
Je sais que vous avez dit que vous voulez avoir un contrat stable. Mais un avantage de pas em> fournir une interface stable est que vos dépendances pourraient alors varier sauvagement avec différentes implémentations, ce qui réduirait le couplage: comme vous l'avez dit, Vous pouvez également mettre en œuvre des dépendances en tant que propriétés (ou arguments), mais cela codera les dépendances, plutôt que de leur faire une mise en œuvre spécifique. Vous découplerez vos implémentations de session spécifiques, mais vous devez toujours dépendre des sessions. P> public interface IInstallationFactory
{
IUser CreateRegisteredUser(Guid userSid);
IPackage CreateKnownPackage(Guid id);
IInstaller CreateInstaller();
}
C'est exactement ce que je disais, mais tellement mieux expliqua mieux. +1 et supprimer le mien.
Nous savons tous que cela est possible par de nombreuses méthodes différentes, mais quelque chose qui a du sens est plus le bienvenu. J'ai défini des propriétés uniquement , puis l'objet est responsable de la contenant une référence à ce qui est transmis à celui-ci: de cette façon, chaque classe mettant en œuvre l'interface sait que la propriété Seul est une injection de dépendance, car les propriétés SET-SET-SEULS sont rarement utilisées. Je ne sais pas si cette méthode est connue sous le nom de bonne pratique ou non, mais pour moi c'est, à partir de maintenant.
Coller de manière rigide à une seule façon de définir des dépendances consiste à jeter des choix de conception. Les autres choix ne sont pas mauvais, ils sont juste différents.
Avec cette conception, vous avez besoin de classes dérivées pour définir les propriétés, mais vous n'exigeez pas que les utilisateurs de la classe remplissent des dépendances. Si un utilisateur instance votre classe, ne remplit pas ces propriétés et appelle une méthode, vous ne pouvez pas lancer. Cela violerait le contrat implicite défini par l'interface. Les deux seules façons de nécessiter une dépendance à remplir sont les paramètres de constructeur et de méthode.
L'interface n'est pas responsable des dépendances. Seule la mise en œuvre sait, ce qu'il faut remplir le contrat.
Il pourrait y avoir une implémentation à l'aide d'une base de données, une autre utilisation du système de fichiers pour persister les données.
Quelle dépendance devrait-elle déclarer l'interface requise? Le gestionnaire de base de données ou le gestionnaire de systèmes de fichiers?