Qu'est-ce que L'Inversion du contrôle?

L'Inversion du contrôle est ce que vous obtenez lorsque votre programme rappelle, par exemple comme un programme gui.

par exemple, dans un menu de la vieille école, vous pourriez avoir:

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

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

dans un programme GUI ou somesuch, à la place nous disons:

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

donc maintenant le contrôle est inversé... au lieu de l'ordinateur d'accepter la saisie de l'utilisateur dans un ordre fixe, l'utilisateur contrôle l'ordre dans lequel les données sont saisies, et lorsque les données sont enregistrées dans la base de données.

fondamentalement, tout ce qui a une boucle d'événement, des callbacks, ou exécute des triggers tombe dans cette catégorie.

Qu'est-ce que L'Inversion du contrôle?

si vous suivez ces deux étapes simples, vous avez fait inversion de contrôle:

1. Séparé ce faire partie de quand à faire partie.
2. S'assurer que quand partie sait que petit comme possible environ ce que partie; et vice versa.

il y a plusieurs techniques possibles pour chacune de ces étapes en fonction de la technologie/langue que vous utilisez pour votre mise en œuvre.

--

le inversion une partie de L'Inversion du contrôle (IoC) est la chose confuse; parce que inversion est le terme relatif. La meilleure façon de comprendre le CIO est d'oublier ce mot!

--

Exemples

• La Gestion Des Événements. Les Gestionnaires d'événements (ce qui à faire partie) -- Événements de collecte (quand à faire partie)
• Interfaces. Composant client (lors de à faire partie) -- Interface du Composant de mise en œuvre (ce qui à faire partie)
• xUnit fixure. L'installation et le Démontage (ce qui à faire partie) -- xUnit cadres des appels à l'Installation, au début et à Démonter à la fin (quand à faire partie)
• modèle de conception de méthode modèle. modèle de méthode partie quand faire -- sous-classe primitive mise en œuvre partie quoi faire
• DLL méthodes de conteneur dans COM. DllMain, DllCanUnload, etc (ce qui à faire partie) -- COM/OS (quand à faire partie)

L'Inversion des commandes est au sujet de la séparation des préoccupations.

sans IoC : vous avez un ordinateur portable ordinateur et vous cassez accidentellement l'écran. Et zut, vous trouvez que le même modèle d'écran d'ordinateur portable est nulle part dans le marché. Donc, vous êtes coincé.

avec IoC : vous avez un ordinateur de bureau et vous cassez accidentellement l'écran. Vous trouvez que vous pouvez simplement saisir presque n'importe quel moniteur de bureau du marché, et il fonctionne bien avec votre bureau.

votre ordinateur de bureau implémente avec succès le CIO dans ce cas. Il accepte un type de variété de moniteurs, tandis que l'ordinateur portable ne le fait pas, il a besoin d'un écran spécifique pour être réparé.

Inversion du contrôle, (ou Cio), est d'environ obtenir la liberté (vous vous mariez, vous avez perdu la liberté et vous êtes contrôlé. Vous avez divorcé, vous venez de mettre en place une Inversion de contrôle. C'est ce que nous avons appelé, "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 en œuvre Inversion du contrôle par la mise en place d'une nouvelle machine à café. Maintenant vous avez la possibilité de choisir l'eau du robinet ou de café.) et moins de dépendance (votre partenaire a un emploi, vous n'avez pas d'emploi, vous dépendez financièrement de votre partenaire, donc vous êtes contrôlé. Vous trouvez un emploi, vous avez mis en œuvre L'Inversion de contrôle. Un bon système informatique encourage la dépendance.)

quand vous utilisez un ordinateur de bureau, vous avez trimé (ou disons, contrôlé). Vous devez assis devant un écran et de 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 avec un ordinateur portable, alors vous un peu inversé le contrôle. Vous pouvez facilement le prendre et vous déplacer. Donc maintenant vous pouvez contrôler où vous êtes avec votre ordinateur, au lieu que votre ordinateur le contrôle.

en mettant en œuvre L'Inversion de contrôle, un logiciel / objet consommateur obtenir plus de contrôles / options sur le logiciel/objets, au lieu d'être contrôlé ou avoir moins d'options.

Avec les idées ci-dessus à l'esprit. Il nous manque encore un élément clé du CIO. Dans le scénario de la recherche des causes, le consommateur de logiciels/objets est un cadre sophistiqué. Cela signifie que le code que vous avez créé n'est pas appelé par vous-même. Maintenant, expliquons pourquoi cette façon fonctionne mieux pour une application web.

supposons que votre code soit un groupe de travailleurs. Ils ont besoin de construire une voiture. Ces travailleurs ont besoin d'un endroit et des outils (un framework logiciel) pour construire la voiture. Un traditionnel cadre logiciel sera comme un garage avec de nombreux outils. Les ouvriers doivent donc faire eux-mêmes un plan et utiliser les outils pour construire la voiture. Construire une voiture n'est pas une affaire facile, il sera vraiment difficile pour les travailleurs de planifier et de coopérer correctement. Un moderne cadre logiciel sera comme une usine automobile moderne avec toutes les installations et les gestionnaires en place. Les travailleurs n'ont pas pour faire n'importe quel plan, les gestionnaires (partie du cadre, ils sont les personnes les plus intelligentes et ont fait le plan le plus sophistiqué) aideront à coordonner de sorte que les travailleurs savent 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 niveau supérieur aux gestionnaires (le cadre). Mais il est bon de ont certains professionnels de l'aide. C'est le concept qui est à la base du CIO.

applications Web modernes avec une architecture MVC dépend du Cadre pour faire le routage URL et mettre des contrôleurs en place pour le cadre à appeler.

L'Injection de dépendance et L'Inversion du contrôle sont liées. L'Injection de dépendance est au niveau micro et L'Inversion du contrôle est au niveau macro . Vous avez à manger chaque bouchée (implement DI) afin de finir un repas (implement IoC).

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

Pour:

• votre code est découplé de sorte que vous pouvez facilement échanger les implémentations d'une interface avec des implémentations alternatives
• Il est un puissant facteur de motivation pour le codage à l'aide d'interfaces au lieu de mises en œuvre
• c'est très facile d'écrire des tests unitaires pour votre code, car il dépend de rien d'autre que les objets qu'il accepte dans son constructeur/setters et vous pouvez facilement les initialiser avec le droit d'objets dans l'isolement.

Inconvénients:

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

personnellement, je vois le points forts du CIO et je les aime vraiment, mais j'ai tendance à éviter le CIO chaque fois que c'est possible parce qu'il transforme votre logiciel en une collection de classes qui ne constituent plus un "vrai" programme, mais juste quelque chose qui doit être assemblé par la configuration XML ou les métadonnées d'annotation et qui tomberait (et tomberait) en morceaux sans lui.

1. Article De Wikipedia . Pour moi, l'inversion du contrôle transforme votre code écrit séquentiellement en une structure de délégation. Au lieu que votre programme contrôle explicitement tout, votre programme établit 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 les vieux jours vous écririez manuellement votre propre boucle d'événements, sondez les bibliothèques du système pour les nouveaux événements. De nos jours, la plupart des API modernes que vous dites simplement les bibliothèques système quels événements Vous êtes intéressés, et il vous permettra de savoir quand ils se produisent.

3. L'Inversion du contrôle est un moyen pratique de réduire la duplication du 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 l'aborder avec l'inversion du contrôle. Inversion de la commande est rendu facile dans de nombreuses langues grâce à la notion de délégués, interfaces, ou même pointeurs de fonction brute.

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

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

comme dans cet exemple avec TextEditor: si vous n'avez qu'un seul correcteur orthographique, peut-être n'est-il pas vraiment nécessaire d'utiliser IoC ? Sauf si tu as besoin d'écrire des tests unitaires ou quelque chose comme ça ...

quoi qu'il en soit: être raisonnable. Les modèles de conception sont bonnes pratiques mais pas la Bible à être prêchée. Ne pas coller partout.

Supposons que vous êtes un objet. Et vous allez au restaurant:

sans IoC : vous demandez" apple", et vous êtes toujours servi apple quand vous demandez plus.

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

donc, évidemment, le CIO est préféré quand vous aimez les variétés.

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

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

1. L'Inversion de commande 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 lorsqu'il est construit. Ces dépendances sont généralement fournies comme interfaces pour un découplage plus poussé et pour soutenir la testabilité. Les conteneurs IoC / DI tels que Castle Windsor, Unity sont des outils (bibliothèques) qui peuvent être utilisés pour fournir le CIO. Ces outils offrent des fonctionnalités étendues au-dessus et au-delà gestion simple de la dépendance, y compris la vie entière, L'interception, la Politique, etc.

2. A. Évite à une composante d'être responsable de la gestion de ses dépendances.
   
   B. Offre la possibilité d'échanger des implémentations de dépendances dans différents environnements.
   
   C. Permet de tester un composant en se moquant des dépendances.
   
   D. Fournit un mécanisme de partage des ressources dans une application.

3. A. Critique dans le développement basé sur les tests. Sans la recherche des causes, il peut être difficile de procéder à des essais, car les composants à l'essai 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 recompiler.
   
   C. Critique s'il y a de nombreuses préoccupations transversales qui besoin de traiter, en partie dans une application d'entreprise.

je vais écrire ma simple compréhension de ces deux termes:

For quick understanding just read examples*

injection de dépendance (DI):

L'injection de dépendances signifie généralement passer un objet dont dépend la méthode, en tant que paramètre à une méthode, plutôt que de voir la méthode créer l'objet dépendant .

dans la pratique, cela signifie que la méthode ne dépend directement d'une mise en œuvre particulière; toute mise en œuvre qui répond aux exigences peut être passée en paramètre.



avec cela, les objets indiquent leurs dépendances. Et au printemps.

cela conduit à un développement d'applications à couplage lâche.

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

Inversion du conteneur de contrôle(IoC):

C'est une caractéristique commune des cadres, IOC gère les objets java

– de l'instanciation à la destruction à travers son BeanFactory.

- les composants Java qui sont instanciés par le conteneur du CIO sont appelés haricots, et le conteneur du CIO gère la portée d'un haricot, les événements du cycle de vie, et toute caractéristique AOP pour laquelle 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 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 ligne directrice de conception sert aux fins suivantes::

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 pas de suppositions sur ce que font les autres systèmes, mais s'appuient sur leurs contrats.

Remplacer les modules n'a pas d'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 l'exemple

explication détaillée

ne répondant qu'à la première partie. Quel est-il?

Inversion de contrôle (IoC) signifie créer des instances de dépendances d'abord et ensuite des instances d'une classe (éventuellement en les injectant par le biais du constructeur), au lieu de créer une instance de la classe d'abord et ensuite l'instance de la classe créant des instances de dépendances. Ainsi, l'inversion de la commande inverse le flux de la commande du programme. à la place de le callee contrôlant le flux de contrôle (tout en créant des dépendances), le caller contrôle le flux de contrôle du programme .

par exemple, la tâche n ° 1 est de créer un objet. Sans concept de recherche des causes, la tâche n ° 1 est censée être exécutée par le programmeur.Mais avec le concept de recherche des causes, la tâche n ° 1 se ferait par conteneur.

en commande courte est inversé de programmeur à conteneur. Il s'agit donc d'une inversion de contrôle.

j'ai trouvé un bon exemple ici .

je suis d'accord avec NilObject , mais je voudrais ajouter à cela:

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

si vous vous retrouvez à copier et coller du code autour, vous faites presque toujours quelque chose mal. Codifié sous le nom de principe de conception Une fois et une seule fois .

il semble que la chose la plus confuse au sujet de" IoC " l'acronyme et le nom pour lequel il se présente est qu'il est trop glamour d'un nom - presque un nom de bruit.

avons-nous vraiment besoin d'un nom pour décrire la différence entre la procédure et la programmation événementielle? OK, si on doit le faire, mais est-ce qu'on doit choisir un nouveau nom "plus grand que la vie" qui confond plus qu'il ne résout?

disons que nous nous réunissons dans un hôtel.

beaucoup de gens, beaucoup de carafes d'eau, beaucoup de gobelets en plastique.

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

après l'heure ou quelque chose, nous avons un plancher couvert de gobelets en plastique et d'eau.

inversez la commande.

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

et elle offre tout le temps aux invités de boire.

quand quelqu'un veut boire, elle prend du verre de serveur, boit et le rend au serveur.

abstraction faite de 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 ressort (un autre conteneur CIO, par exemple: Guice). Au lieu de laisser à l'application de créer ce dont elle a besoin en utilisant de nouveaux mots clés (prenant la tasse en plastique), le conteneur de printemps de Cio offre tout le temps à l'application la même instance (simple) de l'objet nécessaire(verre d'eau).

pensez à vous en tant qu'organisateur d'une telle réunion. Vous avez besoin de la façon de message à l'administration de l'hôtel que

de la réunion, les membres devront verre d'eau, mais pas du 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: -

• http://adfjsf.blogspot.in/2008/05/inversion-of-control.html
• http://martinfowler.com/articles/injection.html
• http://www.shawn-barrett.com/blog/post/Tip-of-the-day-e28093-Inversion-Of-Control.aspx

le Cio est à propos de l'inversion de la relation entre votre code et de code tiers (bibliothèque/cadre):

• dans le développement normal s/w, vous écrivez les méthodes main () méthode et appel "bibliothèque". Vous sont en contrôle :)
• Dans le Cio le "cadre" contrôles main() et appelle à votre méthode. Le Framework est sous contrôle: (

DI (Dependency Injection) est sur la façon dont le contrôle de flux dans l'application. L'application de bureau traditionnelle a eu le flux de contrôle de votre application (main () méthode) à d'autres appels de méthode de bibliothèque, mais avec DI flux de contrôle est inversé que le cadre prend soin de démarrer votre application, l'initialiser et invoquer vos méthodes chaque fois que nécessaire.

À la fin, vous gagnez toujours :)

j'ai trouvé un exemple très clair ici qui explique comment le contrôle est inversée'.

Classique code (sans injection de Dépendance)

Voici comment fonctionne un code n'utilisant pas DI:

• aux besoins de l'Application Foo (par exemple, un contrôleur), donc:
• Application crée Foo
• Application appelle Foo
  • Foo besoins Bar (par exemple un service), donc:
  • Toto crée Bar
  • Foo calls Bar
    • Bar besoins Bim (un service, un dépôt, ...), donc:
    • Bar crée Bim
    • Barre " fait quelque chose

à l'Aide de l'injection de dépendance

Voici comment un code utilisant DI fonctionnera:

• aux besoins de l'Application Foo, qui a besoin de Bar, qui doit Bim, donc:
• Application crée Bim
• Application crée un Bar et lui donne Bim
• Application crée Toto et lui donne un Bar
• Application appelle Foo
  • Foo appels Bar
    • la barre fait quelque chose

le contrôle des dépendances est inversé d'un appel à l'autre.

quels problèmes résout-elle?

rend facile l'échange avec l'implémentation différente des classes injectées. Pendant le test de l'unité, vous pouvez injecter un mannequin mise en œuvre, ce qui rend les tests beaucoup plus faciles.

Ex: supposons que votre application stocke le fichier téléchargé par L'utilisateur dans le lecteur Google, 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, dites, au lieu de GoogleDrive, que vous êtes invité à utiliser la Dropbox. Vous n'avez qu'à écrire une implémentation dropbox pour L'interface StorageServiceInterface. Vous n'avez pas à faire de changements dans le controller tant que Dropbox la mise en œuvre est conforme à L'interface du service de stockage.

pendant les tests, vous pouvez créer le mock pour L'interface StorageServiceInterface avec l'implémentation dummy où toutes les méthodes retournent null (ou n'importe quelle valeur prédéfinie selon votre exigence de test).

à la place si vous aviez la classe controller pour construire l'objet de stockage avec le mot-clé new comme ceci:

class SomeController
{
    private $storage;

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

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

quand vous voulez changer avec la Dropbox mise en œuvre vous devez remplacer toutes les lignes où new GoogleDriveService objet est construit et utiliser le 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-il approprié et quand ne l'est-il pas? À mon avis, vous utilisez DI quand vous pensez qu'il y a (ou il peut y avoir) des implémentations alternatives d'une classe.

Inversion du contrôle est quand vous allez à l'épicerie et votre épouse vous donne la liste des produits à acheter.

en termes de programmation, elle a passé une fonction de rappel getProductList() à la fonction que vous exécutez doShopping() ;

il permet à l'utilisateur de la fonction de définir certaines parties de lui rendre plus flexible.

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

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

il dit:

" toute application non triviale est constituée de deux ou plusieurs classes qui collaborer les uns avec les autres pour effectuer une logique métier. Traditionnellement, chaque objet est responsable de l'obtention de son propre les références aux objets il collabore avec (ses dépendances). Lors de L'application de DI, les objets sont donnés leurs dépendances à la création temps par une entité externe qui coordonne chaque objet dans le système. En d'autres termes, les dépendances sont injectés dans les objets."

programmation parlant

coi en termes simples: C'est l'utilisation de L'Interface comme une façon de spécifier quelque chose (tel un champ ou un paramètre) comme un joker qui peut être utilisé par certaines classes. Il permet la réutilisation du code.

Par exemple, disons que nous avons deux classes : Chien et Chat . Les deux partagent les mêmes qualités / États: âge, Taille, Poids. Donc, au lieu de créer une classe de service appelé DogService et CatService , je peux en créer un seul appelé AnimalService qui permet d'utiliser le chien et le chat seulement s'ils utilisent l'interface IAnimal .

cependant, pragmatiquement parlant, il a un peu en arrière.

a) la Plupart des développeurs ne savent pas comment l'utiliser . Par exemple, je peux créer une classe appelée client et je peux créer automatiquement (en utilisant les outils de L'IDE) une interface appelée ICustomer . Donc, il n'est pas rare de trouver un dossier rempli de classes et d'interfaces, peu importe si les interfaces seront réutilisés ou pas. Ça s'appelle gonflé. Certains pourraient argumenter que "peut-être dans le futur, nous pourrions l'utiliser". :- /

b) Il a des limites. Par exemple, nous allons parler de l'affaire de Chien et Chat et je veux ajouter un nouveau service (fonctionnalités) seulement pour les chiens. Disons que je veux calculer le nombre de jours dont j'ai besoin pour dresser un chien ( trainDays() ), pour le chat c'est inutile, les chats ne peuvent pas être entraînés (je plaisante).

B. 1) si j'ajoute trainDays() au Service AnimalService alors il fonctionne aussi avec les chats et il n'est pas valide du tout.

B. 2) je peux ajouter une condition dans trainDays() où il évalue quelle classe est utilisée. Mais cela briserait complètement le CIO.

B. 3) je peux créer une nouvelle classe de service appelé DogService juste pour la nouvelle fonctionnalité. Mais, il va augmenter la maintenabilité du code parce que nous aurons deux classes de service (avec une fonctionnalité similaire) pour chien et il est mauvais.

L'Inversion du contrôle est un principe générique, alors que L'Injection de dépendances 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 comment les objets se référencent entre eux, 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épendance inverse le contrôle de la construction d'un graphe d'objets. Si dit dans le terme de layman, l'inversion du contrôle implique un changement dans le flux du contrôle dans le programme. Par exemple. Dans l'application autonome traditionnelle, nous avons la méthode principale, d'où le contrôle est passé à d'autres bibliothèques de tiers(dans le cas, nous avons utilisé la fonction de bibliothèque de tiers), mais par l'inversion du contrôle est transféré du code de bibliothèque de tiers à notre code, comme nous prenons le service de bibliothèque de tiers. Mais il y a d'autres aspects qui doivent être inversé dans un programme - par exemple, invocation de méthodes et de threads pour exécuter le code.

pour ceux qui s'intéressent à plus de profondeur sur L'Inversion du contrôle un document a été publié décrivant une image plus complète de L'Inversion du contrôle comme un modèle de conception (OfficeFloor: using office patterns to improve software design http://doi.acm.org/10.1145/2739011.2739013 avec une copie gratuite à télécharger à partir de http://www.officefloor.net/mission.html )

ce qui est indiqué est la relation suivante:

Inversion du témoin (pour les méthodes) = dépendance (état) Injection + Continuation Injection + Thread Injection

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

Il commencer simple et montre des exemples de code.

le consommateur, X, a besoin de la classe consommée, Y, pour accomplir quelque chose. C'est tout bon et naturel, mais est-ce que X a 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 au sujet de Y.

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 encore Y ce qui est intéressant est que X ne le sache pas. Il sait juste qu'il utilise quelque chose qui implémente I.

Lire l'article pour plus d'information et la description des avantages tels que:

• X n'est plus dépendant de Y
• plus souple, mise en œuvre peut être décidé à l'exécution
• Isolation de l'Unité de code, essais plus faciles

...

je comprends que la réponse a déjà été donné ici. Mais je pense toujours, quelques bases au sujet de l'inversion du contrôle doivent être discutées ici en longueur pour les futurs lecteurs.

Inversion de Contrôle (IoC) a été construit sur un principe très simple appelé Hollywood Principe . Et il est dit que,

Ne nous appelez pas, nous vous appellerons

cela signifie que n'allez pas à Hollywood pour réaliser votre rêve, mais si vous en êtes digne, alors Hollywood vous trouvera et réalisera votre rêve. Assez bien inversé, hein?

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

dans notre monde de programmation, Hollywood représentent un cadre générique (peut être écrit par vous ou quelqu'un d'autre), vous représente le code d'utilisateur que vous avez écrit et la tâche représenter la chose que vous voulez accomplir avec votre code. Maintenant, vous n'allez jamais déclencher votre tâche par vous-même, pas au CIO! Vous avez plutôt tout conçu de telle sorte que votre cadre déclenche votre tâche pour vous. 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 pour aller chercher quelqu'un, et ce quelqu'un sait ce qu'il veut être.

Un exemple réel serait donnée ici. Supposons que vous voulez développer une application web. Ainsi, vous créez un cadre qui gérera toutes les choses communes qu'une application web devrait gérer comme traiter une requête http, créer un menu application, servir des pages, gérer des cookies, déclencher des événements, etc.

Et ensuite, vous laissez quelques crochets dans votre cadre où vous pouvez mettre d'autres codes pour générer le menu personnalisé, les pages, les cookies ou la journalisation de certains événements de l'utilisateur, etc. Sur chaque demande de navigateur, votre cadre, et exécute vos codes personnalisés si accro ensuite de le servir au navigateur.

donc, l'idée est assez simple. Plutôt que de créer une application utilisateur qui contrôlera tout, vous créez d'abord un framework réutilisable qui contrôlera tout, puis écrivez vos codes Personnalisés et accrochez-les au framework pour les exécuter à temps.

Laravel et EJB sont des exemples de tels cadres.

référence:

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

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

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

1. Si le numéro de 1 au-dessus . Qu'est-ce que L'Inversion du contrôle?

2. L'entretien est la principale chose qu'il résout pour moi. Cela garantit que j'utilise des interfaces pour que deux classes ne soient pas intimes l'une avec l'autre.

en utilisant un conteneur comme Castle Windsor, il résout les problèmes d'entretien encore mieux. Être en mesure de swap un composant qui va dans une base de données pour une base de données qui utilise la persistance basée sur les fichiers sans changer une ligne de code est génial (changement de configuration, c'est terminé).

et une fois que vous entrez dans les génériques, il obtient encore mieux. Imaginez un éditeur de messages qui reçoit des disques et publie des messages. Il se fiche de ce qu'il publie, mais il a besoin d'un mapper pour prendre quelque chose d'un disque à 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 peut injecter de nombreux types dans cet ensemble de code si je publie différents types de messages. Je peux aussi écrire des mappers qui prennent un enregistrement du même type et les mappent à des messages différents. L'utilisation de L'AI avec des génériques m'a donné la capacité 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 IoC/DI.

je suis définitivement amoureuse du Cio/DI.

3 . Il devient plus approprié à la minute où vous avez un projet de taille moyenne d'un peu plus de complexité. Je dirais que ça devient approprié à la minute où tu commences à ressentir de la douleur.

la création d'un objet dans une classe est appelée "tight coupling", le ressort supprime cette dépendance en suivant un dessin(DI/IOC). Dans lequel l'objet de la classe dans a passé dans le constructeur plutôt que de créer dans la classe. Plus sur nous donnons la variable de référence de super classe dans le constructeur pour définir la structure plus générale.

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 blog ici

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

C'est une pratique où vous laissez le comportement réel viennent de à l'extérieur de la limite (classe de Programmation Orientée Objet). L'entité limite ne connaît que l'abstraction (E. g interface, classe abstraite, délégué en programmation orientée objet) de celui-ci.

2. quels problèmes résout-elle?

en termes de programmation, le CIO tente de résoudre le code monolithique en le rendant modulaire, en découplant diverses parties de celui-ci et en le rendant vérifiable à l'unité.

3. quand est-il approprié et quand pas?

il est approprié la plupart du temps, sauf si vous avez une situation où vous voulez simplement un code monolithique (E. g programme très simple)

grâce au CIO, vous n'êtes pas en train d'embellir vos objets. Votre conteneur CIO le fera et gérera leur durée de vie.

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

il est approprié lorsque vous avez des fonctionnalités qui peuvent changer dans l'avenir ou qui peuvent être différentes selon l'environnement ou la configuration utilisés dans.