oop - Qu'est-ce que l'inversion de contrôle?

Translate

L'inversion de contrôle (ou IoC) peut être assez déroutante lors de sa première rencontre.

  1. Qu'Est-ce que c'est?
  2. Quel problème résout-il?
  3. Quand est-il approprié d'utiliser et quand non?
This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

Les modèles d'inversion de contrôle (IoC) et d'injection de dépendances (DI) visent à supprimer les dépendances de votre code.

Par exemple, supposons que votre application dispose d'un composant éditeur de texte et que vous souhaitez fournir une vérification orthographique. Votre code standard ressemblerait à ceci:

public class TextEditor {

    private SpellChecker checker;

    public TextEditor() {
        this.checker = new SpellChecker();
    }
}

Ce que nous avons fait ici crée une dépendance entre lesTextEditoret leSpellChecker. Dans un scénario IoC, nous ferions plutôt quelque chose comme ceci:

public class TextEditor {

    private IocSpellChecker checker;

    public TextEditor(IocSpellChecker checker) {
        this.checker = checker;
    }
}

Dans le premier exemple de code, nous instancionsSpellChecker (this.checker = new SpellChecker();), ce qui signifie queTextEditorla classe dépend directement de laSpellCheckerclasse.

Dans le deuxième exemple de code, nous créons une abstraction en ayant leSpellCheckerclasse de dépendance dansTextEditorsignature du constructeur (pas d'initialisation de la dépendance dans la classe). Cela nous permet d'appeler la dépendance puis de la passer à la classe TextEditor comme suit:

SpellChecker sc = new SpellChecker; // dependency
TextEditor textEditor = new TextEditor(sc);

Maintenant, le client créant leTextEditorla classe a le contrôle sur lequelSpellCheckerimplémentation à utiliser car nous injectons la dépendance dans leTextEditorSignature.

Ceci est juste un exemple simple, il y aune bonne série d'articlespar Simone Busoli qui l'explique plus en détail.

La source
Translate

L'inversion de contrôle est ce que vous obtenez lorsque votre programme est rappelé, par exemple comme un programme d'interface graphique.

Par exemple, dans un menu old school, vous pourriez avoir:

print "enter your name"
read name
print "enter your address"
read address
etc...
store in database

contrôlant ainsi le flux d'interaction de l'utilisateur.

Dans un programme GUI ou quelque chose comme ça, nous disons à la place:

when the user types in field a, store it in NAME
when the user types in field b, store it in ADDRESS
when the user clicks the save button, call StoreInDatabase

Alors maintenant, le contrôle est inversé ... au lieu que l'ordinateur accepte l'entrée de l'utilisateur dans un ordre fixe, l'utilisateur contrôle l'ordre dans lequel les données sont entrées et le moment où les données sont enregistrées dans la base de données.

Fondamentalement,n'importe quoiavec une boucle d'événement, des rappels ou des déclencheurs d'exécution appartiennent à cette catégorie.

La source
Translate

Qu'est-ce que l'inversion de contrôle?

Si vous suivez ces deux étapes simples, vous avez effectué l'inversion de contrôle:

  1. Séparéquoi-à-faire partie dequand-à-faire partie.
  2. Veiller à ce quequandpartie sait commepeuque possible surquoipartie; et vice versa.

Il existe plusieurs techniques possibles pour chacune de ces étapes en fonction de la technologie / du langage que vous utilisez pour votre implémentation.

--

leinversionune partie de l'inversion de contrôle (IoC) est la chose déroutante; carinversionest le terme relatif. La meilleure façon de comprendre IoC est d'oublier ce mot!

--

Exemples

  • Gestion des événements. Gestionnaires d'événements (partie quoi faire) - Déclenchement d'événements (partie quand faire)
  • Interfaces. Client de composant (partie quand faire) - Implémentation de l'interface de composant (partie que faire)
  • Appareil xUnit. Setup and TearDown (what-to-do part) - Les frameworks xUnit appellent Setup au début et TearDown à la fin (when-to-do part)
  • Modèle de conception de méthode de modèle. template, méthode when-to-do part - implémentation de sous-classe primitive partie what-to-do
  • Méthodes de conteneur DLL dans COM. DllMain, DllCanUnload, etc. (partie quoi faire) - COM / OS (partie quand faire)
La source
Translate

L'inversion des contrôles consiste à séparer les préoccupations.

Sans IoC: Tu as unportablel'ordinateur et vous cassez accidentellement l'écran. Et bon sang, vous trouvez que le même modèle d'écran d'ordinateur portable n'est nulle part sur le marché. Alors vous êtes coincé.

Avec IoC: Tu as unbureaul'ordinateur et vous cassez accidentellement l'écran. Vous constatez que vous pouvez simplement récupérer presque tous les écrans de bureau du marché, et cela fonctionne bien avec votre bureau.

Votre bureau implémente avec succès IoC dans ce cas. Il accepte divers types de moniteurs, contrairement à l'ordinateur portable, il a besoin d'un écran spécifique pour être réparé.

La source
Translate

L'inversion de contrôle, (ou IoC), concerneobtenir la liberté(Vous vous mariez, vous avez perdu la liberté et vous êtes contrôlé. Vous avez divorcé, vous venez de mettre en œuvre l'Inversion de Contrôle. C'est ce que nous appelons «découplé». Un bon système informatique décourage certaines relations très étroites.)plus de flexibilité(La cuisine de votre bureau ne sert que de l'eau du robinet propre, c'est votre seul choix lorsque vous voulez boire. Votre patron a implémenté l'inversion de contrôle en installant une nouvelle machine à café. Vous avez maintenant la possibilité de choisir entre l'eau du robinet ou le café. ) etmoins de dépendance(Votre partenaire a un emploi, vous n'avez pas de travail, vous dépendez financièrement de votre partenaire, vous êtes donc contrôlé. Vous trouvez un emploi, vous avez implémenté l'Inversion de Contrôle. Un bon système informatique encourage la dépendance.)

Lorsque vous utilisez un ordinateur de bureau, vous avez asservi (ou, disons, contrôlé). Vous devez vous asseoir devant un écran et le regarder. Utiliser le clavier pour taper et utiliser la souris pour naviguer. Et un logiciel mal écrit peut vous asservir encore plus. Si vous remplacez votre bureau par un ordinateur portable, vous avez quelque peu inversé le contrôle. Vous pouvez facilement le prendre et vous déplacer. Alors maintenant, vous pouvez contrôler où vous en êtes avec votre ordinateur, au lieu que votre ordinateur le contrôle.

En implémentant l'inversion de contrôle, un consommateur de logiciel / objet obtient plus de contrôles / options sur le logiciel / objets, au lieu d'être contrôlé ou d'avoir moins d'options.

Avec les idées ci-dessus à l'esprit. Nous manquons toujours un élément clé d'IoC. Dans le scénario de l'IoC, le consommateur de logiciel / objet est un cadre sophistiqué. Cela signifie que le code que vous avez créé n'est pas appelé par vous-même. Expliquons maintenant pourquoi cette méthode fonctionne mieux pour une application Web.

Supposons que votre code soit un groupe de nœuds de calcul. Ils ont besoin de construire une voiture. Ces travailleurs ont besoin d'un endroit et d'outils (un cadre logiciel) pour construire la voiture. UNEtraditionnelle framework logiciel sera comme un garage avec de nombreux outils. Les travailleurs doivent donc élaborer eux-mêmes un plan et utiliser les outils pour construire la voiture. Construire une voiture n'est pas une entreprise facile, il sera très difficile pour les travailleurs de planifier et de coopérer correctement. UNEmoderneLe cadre logiciel sera comme une usine automobile moderne avec toutes les installations et les gestionnaires en place. Les travailleurs n'ont pas à faire de plan, les gestionnaires (qui font partie du cadre, ce sont les personnes les plus intelligentes et ont fait le plan le plus sophistiqué) aideront à se coordonner afin que les travailleurs sachent quand faire leur travail (le cadre appelle votre code). Les travailleurs ont juste besoin d'être suffisamment flexibles pour utiliser tous les outils que les gestionnaires leur donnent (en utilisant l'injection de dépendances).

Bien que les travailleurs donnent le contrôle de la gestion du projet au plus haut niveau aux gestionnaires (le cadre). Mais il est bon que des professionnels vous aident. C'est le concept d'IoC vraiment venu.

Les applications Web modernes avec une architecture MVC dépendent du framework pour effectuer le routage d'URL et mettre en place des contrôleurs pour que le framework puisse appeler.

L'injection de dépendance et l'inversion de contrôle sont liées. L'injection de dépendance est aumicroniveau et l'inversion de contrôle est aumacroniveau. Il faut manger chaque bouchée (implémenter DI) pour terminer un repas (implémenter IoC).

La source
ahe
Translate

Avant d'utiliser Inversion of Control, vous devez être bien conscient du fait qu'il a ses avantages et ses inconvénients et vous devez savoir pourquoi vous l'utilisez si vous le faites.

Avantages:

  • Votre code est découplé afin que vous puissiez facilement échanger des implémentations d'une interface avec des implémentations alternatives
  • C'est un puissant facteur de motivation pour coder contre des interfaces au lieu d'implémentations
  • Il est très facile d'écrire des tests unitaires pour votre code car cela ne dépend de rien d'autre que des objets qu'il accepte dans son constructeur / setters et vous pouvez facilement les initialiser avec les bons objets de manière isolée.

Les inconvénients:

  • IoC n'inverse pas seulement le flux de contrôle dans votre programme, il le trouble également considérablement. Cela signifie que vous ne pouvez plus simplement lire votre code et passer d'un endroit à un autre car les connexions qui seraient normalement dans votre code ne sont plus dans le code. Au lieu de cela, c'est dans les fichiers de configuration XML ou les annotations et dans le code de votre conteneur IoC qui interprète ces métadonnées.
  • Il y a une nouvelle classe de bogues où vous obtenez votre configuration XML ou vos annotations erronées et vous pouvez passer beaucoup de temps à découvrir pourquoi votre conteneur IoC injecte une référence nulle dans l'un de vos objets sous certaines conditions.

Personnellement, je vois les points forts d'IoC et je les aime beaucoup mais j'ai tendance à éviter l'IoC autant que possible car cela transforme votre logiciel en un ensemble de classes qui ne constituent plus un "vrai" programme mais juste quelque chose qui doit être assemblé Configuration XML ou métadonnées d'annotation et tomberait (et s'effondrerait) sans elle.

La source
Translate
  1. Article Wikipédia. Pour moi, l'inversion du contrôle transforme votre code écrit séquentiellement et le transforme en une structure de délégation. Au lieu que votre programme contrôle tout explicitement, votre programme met en place une classe ou une bibliothèque avec certaines fonctions à appeler lorsque certaines choses se produisent.

  2. Il résout la duplication de code. Par exemple, dans l'ancien temps, vous écriviez manuellement votre propre boucle d'événements, en interrogeant les bibliothèques système pour de nouveaux événements. De nos jours, la plupart des API modernes indiquent simplement aux bibliothèques système les événements qui vous intéressent et vous avertissent quand ils se produisent.

  3. L'inversion de contrôle est un moyen pratique de réduire la duplication de code, et si vous vous retrouvez à copier une méthode entière et à ne changer qu'une petite partie du code, vous pouvez envisager de la résoudre avec l'inversion de contrôle. L'inversion de contrôle est facilitée dans de nombreux langages grâce au concept de délégués, d'interfaces ou même de pointeurs de fonction bruts.

    Il n'est pas approprié de l'utiliser dans tous les cas, car le déroulement d'un programme peut être plus difficile à suivre lorsqu'il est écrit de cette façon. C'est un moyen utile de concevoir des méthodes lors de l'écriture d'une bibliothèque qui sera réutilisée, mais elle doit être utilisée avec parcimonie dans le cœur de votre propre programme à moins que cela ne résolve vraiment un problème de duplication de code.

La source
Translate

Mais je pense que vous devez être très prudent avec cela. Si vous abusez de ce modèle, vous ferez une conception très compliquée et un code encore plus compliqué.

Comme dans cet exemple avec TextEditor: si vous n'avez qu'un seul SpellChecker, peut-être n'est-il pas vraiment nécessaire d'utiliser IoC? À moins que vous n'ayez besoin d'écrire des tests unitaires ou quelque chose comme ça ...

Quoi qu'il en soit: soyez raisonnable. Le modèle de conception estbonnes pratiquesmais pas la Bible à prêcher. Ne le collez pas partout.

La source
Translate

Supposons que vous soyez un objet. Et vous allez au restaurant:

Sans IoC: vous demandez "pomme", et on vous sert toujours de la pomme quand vous en demandez plus.

Avec IoC: Vous pouvez demander des "fruits". Vous pouvez obtenir différents fruits à chaque fois que vous êtes servi. par exemple, pomme, orange ou melon d'eau.

Donc, évidemment, IoC est préféré lorsque vous aimez les variétés.

La source
Translate

IoC / DI pour moi pousse les dépendances vers les objets appelants. Super simple.

La réponse non technique est de pouvoir échanger un moteur dans une voiture juste avant de l'allumer. Si tout va bien (l'interface), vous êtes bon.

La source
Translate
  1. L'inversion de contrôle est un modèle utilisé pour découpler les composants et les couches du système. Le modèle est implémenté en injectant des dépendances dans un composant lors de sa construction. Ces dépendances sont généralement fournies comme interfaces pour un découplage supplémentaire et pour prendre en charge la testabilité. Les conteneurs IoC / DI tels que Castle Windsor, Unity sont des outils (bibliothèques) qui peuvent être utilisés pour fournir l'IoC. Ces outils fournissent des fonctionnalités étendues au-delà de la simple gestion des dépendances, y compris la durée de vie, l'AOP / Interception, la politique, etc.

  2. une. Empêche un composant d'être responsable de la gestion de ses dépendances.
    b. Permet de permuter les implémentations de dépendances dans différents environnements.
    c. Permet à un composant d'être testé en se moquant des dépendances.
    ré. Fournit un mécanisme de partage des ressources dans une application.

  3. une. Critique lors du développement piloté par les tests. Sans IoC, il peut être difficile à tester, car les composants testés sont fortement couplés au reste du système.
    b. Critique lors du développement de systèmes modulaires. Un système modulaire est un système dont les composants peuvent être remplacés sans nécessiter de recompilation.
    c. Critique s'il y a de nombreuses préoccupations transversales qui doivent être traitées, en partie dans une application d'entreprise.

La source
Translate

J'écrirai ma compréhension simple de ces deux termes:

For quick understanding just read examples*

Injection de dépendance (DI):
L'injection de dépendance signifie généralementpasser un objet dont la méthode dépend, en tant que paramètre à une méthode, plutôt que de laisser la méthode créer l'objet dépendant.
Ce que cela signifie en pratique, c'est que la méthode ne dépend pas directement d'une mise en œuvre particulière; toute implémentation qui répond aux exigences peut être passée en paramètre.

Avec ces objets, dites leurs dépendances. Et le printemps le rend disponible.
Cela conduit à un développement d'applications faiblement couplé.

Quick Example:EMPLOYEE OBJECT WHEN CREATED,
              IT WILL AUTOMATICALLY CREATE ADDRESS OBJECT
   (if address is defines as dependency by Employee object)

Conteneur d'inversion de contrôle (IoC):
C'est une caractéristique commune des cadres, IOCgère les objets java
- de l'instanciation à la destruction via sa BeanFactory.
-Les composants Java instanciés par le conteneur IoC sont appelés beans, et leLe conteneur IoC gère la portée d'un bean, les événements du cycle de vie et toutes les fonctionnalités AOPpour lequel il a été configuré et codé.

QUICK EXAMPLE:Inversion of Control is about getting freedom, more flexibility, and less dependency. When you are using a desktop computer, you are slaved (or say, controlled). You have to sit before a screen and look at it. Using keyboard to type and using mouse to navigate. And a bad written software can slave you even more. If you replaced your desktop with a laptop, then you somewhat inverted control. You can easily take it and move around. So now you can control where you are with your computer, instead of computer controlling it.

En implémentant l'inversion de contrôle, un consommateur de logiciel / objet obtient plus de contrôles / options sur le logiciel / objets, au lieu d'être contrôlé ou d'avoir moins d'options.

L'inversion du contrôle en tant que directive de conception sert les objectifs suivants:

Il y a un découplage entre l'exécution d'une certaine tâche et la mise en œuvre.
Chaque module peut se concentrer sur ce pour quoi il est conçu.
Les modules ne font aucune hypothèse sur ce que font les autres systèmes mais s'appuient sur leurs contrats.
Le remplacement des modules n'a aucun effet secondaire sur les autres modules
Je vais garder les choses abstraites ici, vous pouvez visiter les liens suivants pour une compréhension détaillée du sujet.
Une bonne lecture avec exemple

Explication détaillée

La source
Translate

Répondre uniquement à la première partie. Qu'Est-ce que c'est?

Inversion of Control (IoC) signifie créer des instances de dépendances première et dernière instance d'une classe (éventuellement en les injectant via le constructeur), au lieu de créer d'abord une instance de la classe, puis l'instance de classe créant des instances de dépendances. Ainsi, inversion de contrôleinverselaflux de contrôledu programme.Au lieu delacontrôle de l'appelélaflux de contrôle(lors de la création de dépendances), lel'appelant contrôle le flux de contrôle du programme.

La source
Translate

Par exemple, la tâche n ° 1 consiste à créer un objet. Sans le concept IOC, la tâche n ° 1 est censée être effectuée par le programmeur, mais avec le concept IOC, la tâche n ° 1 serait effectuée par conteneur.

En bref, le contrôle est inversé du programmeur au conteneur. Donc, cela s'appelle une inversion de contrôle.

J'ai trouvé un bon exempleici.

La source
Translate

Disons que nous faisons quelques rendez-vous dans un hôtel.

Beaucoup de monde, de nombreuses carafes d'eau, de nombreux gobelets en plastique.

Quand quelqu'un veut boire, elle remplit une tasse, boit et jette une tasse sur le sol.

Après une heure ou quelque chose du genre, nous avons un sol recouvert de gobelets en plastique et d'eau.

Laissez inverser le contrôle.

La même réunion au même endroit, mais au lieu de gobelets en plastique, nous avons un serveur avec une tasse en verre (Singleton)

et elle propose tout le temps aux clients de boire.

Quand quelqu'un veut boire, elle sort du verre du serveur, le boit et le rend au serveur.

Laissant de côté la question de l'hygiène, la dernière forme de contrôle du processus de consommation est beaucoup plus efficace et économique.

Et c'est exactement ce que fait le Spring (un autre conteneur IoC, par exemple: Guice). Au lieu de laisser l'application créer ce dont elle a besoin en utilisant un nouveau mot-clé (prendre une tasse en plastique), le conteneur Spring IoC offre toujours à l'application la même instance (singleton) de l'objet nécessaire (verre d'eau).

Pensez à vous comme organisateur d'une telle réunion. Vous avez besoin du moyen d'envoyer un message à l'administration de l'hôtel

les membres de la réunion auront besoin d'un verre d'eau mais pas d'un morceau de gâteau.

Exemple:-

public class MeetingMember {

    private GlassOfWater glassOfWater;

    ...

    public void setGlassOfWater(GlassOfWater glassOfWater){
        this.glassOfWater = glassOfWater;
    }
    //your glassOfWater object initialized and ready to use...
    //spring IoC  called setGlassOfWater method itself in order to
    //offer to meetingMember glassOfWater instance

}

Liens utiles:-

La source
Translate

je suis d'accord avecNilObject, mais j'aimerais ajouter à ceci:

si vous vous trouvez en train de copier une méthode entière et de ne changer qu'une petite partie du code, vous pouvez envisager de l'aborder avec une inversion de contrôle

Si vous vous surprenez à copier et coller du code, vous faites presque toujoursquelque chosefaux. Codifié comme principe de conceptionUne et une seule fois.

La source
Translate

Il semble que la chose la plus déroutante à propos de "IoC", l'acronyme et le nom pour lequel il se présente, c'est que c'est un nom trop glamour - presque un nom bruyant.

Avons-nous vraiment besoin d'un nom pour décrire la différence entre la programmation procédurale et événementielle? OK, si nous en avons besoin, mais devons-nous choisir un tout nouveau nom «plus grand que nature» qui déroute plus qu'il ne résout?

La source
Translate

Inversion de contrôlec'est lorsque vous allez à l'épicerie et que votre femme vous donne la liste des produits à acheter.

En termes de programmation, elle a passé une fonction de rappelgetProductList()à la fonction que vous exécutez -doShopping().

Il permet à l'utilisateur de la fonction de définir certaines parties de celle-ci, ce qui la rend plus flexible.

La source
Translate

IoC consiste à inverser la relation entre votre code et le code tiers (bibliothèque / framework):

  • Dans le développement normal de s / w, vous écrivez leprincipale()méthode et appelez les méthodes "bibliothèque".Toisont aux commandes :)
  • Dans IoC, les contrôles "framework"principale()et appelle vos méthodes. leCadreest aux commandes :(

DI (Dependency Injection) concerne la manière dont le contrôle circule dans l'application. L'application de bureau traditionnelle avait un flux de contrôle de votre application (méthode main ()) vers d'autres appels de méthode de bibliothèque, mais avec le flux de contrôle DI est inversé, le framework se charge de démarrer votre application, de l'initialiser et d'appeler vos méthodes chaque fois que nécessaire.

En fin de compte, vous gagnez toujours :)

La source
Translate

Une explication écrite très simple peut être trouvée ici

http://binstock.blogspot.in/2008/01/excellent-explanation-of-dependency.html

Ça dit -

"Toute application non triviale est constituée de deux classes ou plus qui collaborent entre elles pour exécuter une logique métier. Traditionnellement, chaque objet est responsable de l'obtention de ses propres références aux objets avec lesquels il collabore (ses dépendances). Lors de l'application de DI, le les dépendances sont données aux objets au moment de la création par une entité externe qui coordonne chaque objet du système. En d'autres termes, les dépendances sont injectées dans les objets. "

La source
Translate

L'inversion de contrôle est un principe générique, tandis que l'injection de dépendance réalise ce principe comme un modèle de conception pour la construction de graphes d'objets (c'est-à-dire que la configuration contrôle la façon dont les objets se référencent les uns aux autres, plutôt que l'objet lui-même contrôlant comment obtenir la référence à un autre objet).

En regardant l'inversion de contrôle comme un modèle de conception, nous devons regarder ce que nous inversons. L'injection de dépendances inverse le contrôle de la construction d'un graphique d'objets. Si elle est dite en termes simples, l'inversion de contrôle implique un changement dans le flux de contrôle dans le programme. Par exemple. Dans l'application autonome traditionnelle, nous avons la méthode principale, à partir de laquelle le contrôle est transmis à d'autres bibliothèques tierces (au cas où nous aurions utilisé la fonction de bibliothèque tierce), mais par inversion du contrôle, le contrôle est transféré du code de la bibliothèque tierce à notre code , car nous prenons le service de bibliothèque tierce. Mais il y a d'autres aspects qui doivent être inversés dans un programme - par exemple, l'invocation de méthodes et de threads pour exécuter le code.

Pour ceux qui s'intéressent davantage à l'inversion du contrôle, un article a été publié décrivant une image plus complète de l'inversion du contrôle en tant que modèle de conception (OfficeFloor: utiliser des modèles de bureau pour améliorer la conception de logicielshttp://doi.acm.org/10.1145/2739011.2739013avec une copie gratuite disponible en téléchargement surhttp://www.officefloor.net/about.html).

Ce qui est identifié est la relation suivante:

Inversion de contrôle (pour les méthodes) = Dépendance (état) Injection + Continuation Injection + Thread Injection

Résumé de la relation ci-dessus pour l'inversion de contrôle disponible -http://dzone.com/articles/inversion-of-coupling-control

La source
Translate

J'ai trouvé un exemple très clairicice qui explique comment le «contrôle est inversé».

Code classique (sans injection de dépendances)

Voici comment un code n'utilisant pas DI fonctionnera à peu près:

  • L'application a besoin de Foo (par exemple un contrôleur), donc:
  • L'application crée Foo
  • Application calls Foo
    • Foo a besoin de Bar (par exemple un service), donc:
    • Foo crée un bar
    • Foo calls Bar
      • Bar a besoin de Bim (un service, un référentiel,…), donc:
      • Bar crée Bim
      • Le bar fait quelque chose

Utilisation de l'injection de dépendances

Voici comment un code utilisant DI fonctionnera à peu près:

  • L'application a besoin de Foo, qui a besoin de Bar, qui a besoin de Bim, donc:
  • L'application crée Bim
  • L'application crée Bar et lui donne Bim
  • L'application crée Foo et lui donne Bar
  • Application calls Foo
    • Foo calls Bar
      • Le bar fait quelque chose

Le contrôle des dépendances est inversé de celui qui est appelé à celui qui appelle.

Quels problèmes résout-il?

L'injection de dépendances facilite l'échange avec les différentes implémentations des classes injectées. Pendant les tests unitaires, vous pouvez injecter une implémentation factice, ce qui facilite beaucoup les tests.

Ex: Supposons que votre application stocke le fichier téléchargé par l'utilisateur dans Google Drive, avec DI votre code de contrôleur peut ressembler à ceci:

class SomeController
{
    private $storage;

    function __construct(StorageServiceInterface $storage)
    {
        $this->storage = $storage;
    }

    public function myFunction () 
    {
        return $this->storage->getFile($fileName);
    }
}

class GoogleDriveService implements StorageServiceInterface
{
    public function authenticate($user) {}
    public function putFile($file) {}
    public function getFile($file) {}
}

Lorsque vos exigences changent, par exemple, au lieu de GoogleDrive, vous êtes invité à utiliser Dropbox. Il vous suffit d'écrire une implémentation de dropbox pour StorageServiceInterface. Vous ne devez apporter aucune modification au contrôleur tant que l'implémentation de Dropbox adhère à StorageServiceInterface.

Pendant le test, vous pouvez créer la maquette pour StorageServiceInterface avec l'implémentation factice où toutes les méthodes renvoient null (ou toute valeur prédéfinie selon vos besoins de test).

Au lieu de cela, si vous aviez la classe de contrôleur pour construire l'objet de stockage avec lenewmot-clé comme celui-ci:

class SomeController
{
    private $storage;

    function __construct()
    {
        $this->storage = new GoogleDriveService();
    }

    public function myFunction () 
    {
        return $this->storage->getFile($fileName);
    }
}

Lorsque vous souhaitez modifier avec l'implémentation Dropbox, vous devez remplacer toutes les lignes oùnewL'objet GoogleDriveService est construit et utilise DropboxService. En outre, lors du test de la classe SomeController, le constructeur attend toujours la classe GoogleDriveService et les méthodes réelles de cette classe sont déclenchées.

Quand est-ce approprié et quand non?À mon avis, vous utilisez DI lorsque vous pensez qu'il existe (ou qu'il peut y avoir) des implémentations alternatives d'une classe.

La source
Translate

J'aime cette explication:http://joelabrahamsson.com/inversion-of-control-an-introduction-with-examples-in-net/

Il commence simple et montre également des exemples de code.

enter image description here

Le consommateur, X, a besoin de la classe consommée, Y, pour accomplir quelque chose. Tout cela est bon et naturel, mais X a-t-il vraiment besoin de savoir qu'il utilise Y?

N'est-il pas suffisant que X sache qu'il utilise quelque chose qui a le comportement, les méthodes, les propriétés, etc. de Y sans savoir qui implémente réellement le comportement?

En extrayant une définition abstraite du comportement utilisé par X dans Y, illustrée comme I ci-dessous, et en laissant le consommateur X utiliser une instance de cela au lieu de Y, il peut continuer à faire ce qu'il fait sans avoir à connaître les détails de Y.

enter image description here

Dans l'illustration ci-dessus, Y implémente I et X utilise une instance de I. Bien qu'il soit tout à fait possible que X utilise toujours Y, ce qui est intéressant, c'est que X ne le sait pas. Il sait juste qu'il utilise quelque chose qui implémente I.

Lisez l'article pour plus d'informations et une description des avantages tels que:

  • X ne dépend plus de Y
  • Plus flexible, la mise en œuvre peut être décidée lors de l'exécution
  • Isolation de l'unité de code, tests plus faciles

...

La source
Translate

Programmation orale

IoC en termes simples: c'est l'utilisation d'Interface comme moyen de quelque chose de spécifique (tel un champ ou un paramètre) comme joker qui peut être utilisé par certaines classes. Il permet la réutilisation du code.

Par exemple, disons que nous avons deux classes:ChienetChat. Les deux partagent les mêmes qualités / états: âge, taille, poids. Donc, au lieu de créer une classe de service appeléeChienServiceetCatService, Je peux en créer un seul appeléService animalierqui permet d'utiliser Dog et Cat uniquement s'ils utilisent l'interfaceIAnimal.

Cependant, d'un point de vue pragmatique, il y a des revers.

une)La plupart des développeurs ne savent pas comment l'utiliser. Par exemple, je peux créer une classe appeléeClientetJe peux créer automatiquement(en utilisant les outils de l'EDI) une interface appeléeIClient. Il n'est donc pas rare de trouver un dossier rempli de classes et d'interfaces, peu importe si les interfaces seront réutilisées ou non. Cela s'appelle BLOATED. Certaines personnes pourraient affirmer que "peut-être dans le futur nous pourrons l'utiliser". : - |

b) Il a quelques limites. Par exemple, parlons du cas deChienetChatet je souhaite ajouter un nouveau service (fonctionnalité) uniquement pour les chiens. Disons que je veux calculer le nombre de jours dont j'ai besoin pour former un chien (trainDays()), pour le chat c'est inutile, les chats ne peuvent pas être dressés (je plaisante).

b.1) Si j'ajoutetrainDays()au serviceAnimalServicealors cela fonctionne aussi avec les chats et ce n'est pas du tout valide.

b.2) Je peux ajouter une condition danstrainDays()où il évalue quelle classe est utilisée. Mais cela brisera complètement l'IoC.

b.3) Je peux créer une nouvelle classe de service appeléeChienServicejuste pour la nouvelle fonctionnalité. Mais cela augmentera la maintenabilité du code car nous aurons deux classes de service (avec des fonctionnalités similaires) pourChienet c'est mauvais.

La source
Translate

Je crois comprendre que la réponse a déjà été donnée ici. Mais je pense toujours que certaines notions de base sur l'inversion de contrôle doivent être discutées ici en détail pour les futurs lecteurs.

Inversion of Control (IoC) a été construit sur un principe très simple appeléPrincipe d'Hollywood. Et il dit que,

Ne nous appelez pas, nous vous appellerons

Cela signifie que n'allez pas à Hollywood pour réaliser votre rêve plutôt que si vous en êtes digne, Hollywood vous trouvera et réalisera votre rêve. Assez inversé, hein?

Maintenant, lorsque nous discutons du principe d'IoC, nous avons l'habitude d'oublier Hollywood. Pour IoC, il doit y avoir trois éléments, un Hollywood, vous et une tâche comme pour réaliser votre rêve.

Dans notre monde de la programmation,Hollywoodreprésentent un cadre générique (peut être écrit par vous ou par quelqu'un d'autre),toireprésentent le code utilisateur que vous avez écrit etla tâchereprésentent ce que vous voulez accomplir avec votre code. Désormais, vous n'allez plus jamais déclencher votre tâche par vous-même, pas dans IoC! Au contraire, vous avez tout conçu de telle sorte que votre cadre déclenchera votre tâche à votre place. Ainsi, vous avez construit un cadre réutilisable qui peut faire de quelqu'un un héros ou un autre un méchant. Mais ce cadre est toujours en charge, il sait quand choisir quelqu'un et que quelqu'un ne sait que ce qu'il veut être.

Un exemple concret serait donné ici. Supposons que vous souhaitiez développer une application Web. Ainsi, vous créez un cadre qui gérera toutes les choses courantes qu'une application Web devrait gérer comme la gestion de la requête http, la création du menu d'application, le service de pages, la gestion des cookies, le déclenchement d'événements, etc.

Et puis vous laissez quelques crochets dans votre framework où vous pouvez mettre d'autres codes pour générer un menu personnalisé, des pages, des cookies ou enregistrer certains événements utilisateur, etc. À chaque demande du navigateur, votre framework s'exécutera et exécutera vos codes personnalisés s'il est accroché puis le servira en retour au navigateur.

Donc, l'idée est assez simple. Plutôt que de créer une application utilisateur qui contrôlera tout, commencez par créer un framework réutilisable qui contrôlera tout, puis écrivez vos codes personnalisés et accrochez-le au framework pour les exécuter à temps.

Laravel et EJB sont des exemples de tels frameworks.

Référence:

https://martinfowler.com/bliki/InversionOfControl.html

https://en.wikipedia.org/wiki/Inversion_of_control

La source
Translate

L'inversion du contrôle consiste à transférer le contrôle de la bibliothèque au client. Cela a plus de sens lorsque nous parlons d'un client qui injecte (transmet) une valeur de fonction (expression lambda) dans une fonction d'ordre supérieur (fonction de bibliothèque) qui contrôle (change) le comportement de la fonction de bibliothèque. Un client ou un framework qui injecte des dépendances de bibliothèque (qui portent un comportement) dans des bibliothèques peut également être considéré comme IoC

La source
Translate
  1. Donc numéro 1au dessus de. Qu'est-ce que l'inversion de contrôle?

  2. La maintenance est la première chose qu'elle résout pour moi. Cela garantit que j'utilise des interfaces afin que deux classes ne soient pas intimes l'une avec l'autre.

En utilisant un conteneur comme Castle Windsor, il résout encore mieux les problèmes de maintenance. Pouvoir échanger un composant qui va dans une base de données pour un qui utilise la persistance basée sur des fichiers sans changer une ligne de code est génial (changement de configuration, vous avez terminé).

Et une fois que vous vous lancez dans les génériques, ça va encore mieux. Imaginez avoir un éditeur de messages qui reçoit des enregistrements et publie des messages. Il ne se soucie pas de ce qu'il publie, mais il a besoin d'un mappeur pour prendre quelque chose d'un enregistrement à un message.

public class MessagePublisher<RECORD,MESSAGE>
{
    public MessagePublisher(IMapper<RECORD,MESSAGE> mapper,IRemoteEndpoint endPointToSendTo)
    {
      //setup
    }
}

Je l'ai écrit une fois, mais maintenant je peux injecter de nombreux types dans cet ensemble de code si je publie différents types de messages. Je peux également écrire des mappeurs qui prennent un enregistrement du même type et les mappent à différents messages. L'utilisation de DI avec des génériques m'a donné la possibilité d'écrire très peu de code pour accomplir de nombreuses tâches.

Oh oui, il y a des problèmes de testabilité, mais ils sont secondaires aux avantages de l'IoC / DI.

J'adore vraiment IoC / DI.

3. Cela devient plus approprié dès que vous avez un projet de taille moyenne d'un peu plus complexe. Je dirais que cela devient approprié dès que vous commencez à ressentir de la douleur.

La source
Translate

La création d'un objet dans une classe est appelée couplage serré, Spring supprime cette dépendance en suivant un modèle de conception (DI / IOC). Dans quel objet de classe est passé dans le constructeur plutôt que dans la création de la classe. De plus, nous donnons une variable de référence de super classe dans le constructeur pour définir une structure plus générale.

La source
Translate

En utilisant IoC, vous ne créez pas de nouveau vos objets. Votre conteneur IoC le fera et en gérera la durée de vie.

Cela résout le problème d'avoir à changer manuellement chaque instanciation d'un type d'objet à un autre.

Il convient lorsque vous disposez de fonctionnalités susceptibles de changer dans le futur ou différentes selon l'environnement ou la configuration utilisé dans.

La source
Bertha Lee
Translate

Pour comprendre le concept, l'inversion de contrôle (IoC) ou le principe d'inversion de dépendance (DIP) implique deux activités: l'abstraction et l'inversion. L'injection de dépendances (DI) n'est qu'une des rares méthodes d'inversion.

Pour en savoir plus à ce sujet, vous pouvez lire mon blogIci

  1. Qu'Est-ce que c'est?

C'est une pratique où vous laissez le comportement réel venir de l'extérieur de la limite (classe en programmation orientée objet). L'entité frontière ne connaît que l'abstraction (par exemple, interface, classe abstraite, délégué en programmation orientée objet) de celle-ci.

  1. Quels problèmes résout-il?

En termes de programmation, IoC tente de résoudre le code monolithique en le rendant modulaire, en découplant diverses parties de celui-ci et en le rendant testable unitaire.

  1. Quand est-ce approprié et quand non?

C'est approprié la plupart du temps, sauf si vous avez une situation où vous voulez juste du code monolithique (par exemple un programme très simple)

La source