Inversion du contrôle par rapport à L'Injection de dépendance

en bref, IoC est un terme beaucoup plus large qui inclut, mais n'est pas limité à, DI

le terme "Inversion du contrôle" (IoC) désignait à l'origine tout type de style de programmation dans lequel une cadre ou l'exécution contrôlée le flux du programme

avant que DI ait un nom, les gens ont commencé à se référer à des cadres qui gèrent les dépendances comme L'Inversion de contrôle, et bientôt, le sens de IoC progressivement dérivé vers cette signification particulière: Inversion du contrôle des dépendances.

Inversion de contrôle (coi) signifie que les objets ne créent pas d'autres objets sur lesquels ils se fondent pour faire leur travail. Au lieu de cela, ils obtiennent les objets dont ils ont besoin d'une source externe (par exemple, un fichier de configuration xml).

l'Injection de Dépendance (DI) signifie que c'est fait, sans que l'objet de l'intervention, le plus souvent par un cadre de la composante qui passe paramètres du constructeur et propriétés définies.

DI est un sous-ensemble de la COI

• CIO signifie que les objets ne créent pas d'autres objets sur lesquels ils se fondent pour faire leur travail. Ils obtiennent plutôt les objets dont ils ont besoin d'un service extérieur (par exemple, un fichier xml ou un service d'application unique). 2 implémentations de IoC, j'utilise, sont DI et ServiceLocator.
• DI signifie que le principe du CIO consistant à obtenir un objet dépendant est appliqué sans des objets concrets mais des abstractions (interfaces). Cela rend tous les composants en chaîne testable, car le composant de niveau supérieur ne dépend pas du composant de niveau inférieur, seulement de l'interface. Mock implémente ces interfaces.

voici quelques autres techniques pour atteindre la COI .

IOC (Inversion du contrôleur) : donner le contrôle au conteneur pour obtenir une instance de l'objet est appelé Inversion du contrôle., signifie qu'au lieu de vous créez un objet en utilisant le nouvel opérateur, laissez le conteneur le faire pour vous.

DI (Dependency Injection) : la manière d'injecter des propriétés à un objet est appelée injection de dépendance.

We have three types of Dependency injection
    1)  Constructor Injection
    2)  Setter/Getter Injection
    3)  Interface Injection

printemps supportera seulement Injection du constructeur et Injection du Setter/Getter.

source

coi ( I nversion o f C ontrol) :- c'est un terme générique et mis en œuvre de plusieurs façons (événements, délégués, etc.).

DI ( D ependency I njection):-DI est un sous-type de IoC et est mis en œuvre par injection de constructeur, injection de setter ou injection D'Interface .

mais, le ressort ne supporte que les deux types suivants:

• Injection Par Mutateur
  • DI est réalisé en appelant les méthodes de setter sur les haricots de l'utilisateur après avoir invoqué un constructeur sans argument ou sans argument statique méthode d'usine pour instancier leur haricot.
• Constructeur D'Injection
  • di basé sur le constructeur est réalisé en invoquant un constructeur avec un certain nombre d'arguments, chacun représentant un collaborateur.En utilisant ceci, nous pouvons valider que les fèves injectées ne sont pas nulles et échouent rapidement(temps de compilation), donc en démarrant l'application elle-même nous obtenons NullPointerException: bean does not exist . L'injection par le constructeur est une bonne pratique d'injection dépendance.

mais la documentation du ressort dit qu'ils sont identiques.

http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-introduction

à la première ligne " le COI est également connu sous le nom de dependency injection (DI) ".

IoC - L'Inversion du contrôle est un terme générique, indépendant du langage, il n'est pas en fait créer les objets, mais décrire dans quelle mode objet est créé.

DI - L'Injection de dépendance est un terme concret, dans lequel nous fournissons des dépendances de l'objet au temps d'exécution en utilisant différentes techniques d'injection à savoir. Injection de Setter, injection de constructeur ou par injection D'Interface.

L'Inversion du contrôle est un paradigme de conception dans le but de donner plus de contrôle aux composants ciblés de votre application, ceux qui font le travail.

L'injection de dépendances est un modèle utilisé pour créer des instances d'objets sur lesquels d'autres objets se basent sans savoir au moment de la compilation quelle classe sera utilisée pour fournir cette fonctionnalité.

il existe plusieurs techniques de base pour mettre en œuvre l'inversion de contrôle. Ce sont:

• utilisant un dessin d'usine
  
  
• utilisant un modèle de localisateur de service
  
  
• en utilisant une injection de dépendance de n'importe quel type donné ci-dessous:
  
  
  
  1). Une injection de constructeur
  
  2). Une injection de setter
  
  3). Une injection d'interface

puisque toutes les réponses mettent l'accent sur la théorie, je voudrais démontrer avec un exemple la première approche:

supposons que nous construisions une application qui contient une fonctionnalité pour envoyer des messages de confirmation SMS Une fois que la commande a été expédiée. Nous aurons deux classes, l'une chargée de l'envoi du SMS (SMSService), et l'autre chargée de la saisie des entrées des utilisateurs (UIHandler), notre code ressemblera à celui ci-dessous:

public class SMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
    }
}

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        SMSService _SMSService = new SMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

ci-dessus la mise en œuvre n'est pas mauvaise, mais il ya peu de questions:

- ) Supposons que sur l'environnement de développement, vous voulez enregistrer SMSs envoyé à un fichier texte au lieu d'utiliser la passerelle SMS, pour y arriver; nous finirons par changer l'implémentation concrète de (SMSService) avec une autre implémentation, nous perdons de la flexibilité et sommes forcés de réécrire le code dans ce cas.

-) Nous allons finir par le mélange des responsabilités des classes, notre (UIHandler) ne doit jamais savoir à propos de la mise en œuvre concrète de (SMSService), ceci devrait être fait en dehors des classes en utilisant des "Interfaces". Lorsque cela est mis en œuvre, il nous donnera la possibilité de changer le comportement du système en échangeant le (SMSService) utilisé avec un autre service simulé qui implémente la même interface, ce service sauvera SMSs à un fichier texte au lieu de l'Envoyer à mobileNumber.

pour corriger les problèmes ci-dessus, nous utilisons des Interfaces qui seront mises en œuvre par notre (SMSService) et le nouveau (MockSMSService), essentiellement la nouvelle Interface (ISMSService) exposera les mêmes comportements des deux services que le code ci-dessous:

public interface ISMSService
{
    void SendSMS(string phoneNumber, string body);
}

alors nous allons changer notre implémentation (SMSService) pour implémenter l'interface (ISMSService):

public class SMSService : ISMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
        Console.WriteLine("Sending SMS using gateway to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

maintenant nous allons pouvoir créer un nouveau service de maquette (MockSMSService) avec une implémentation totalement différente en utilisant la même interface:

public class MockSMSService :ISMSService
{
    public void SendSMS(string phoneNumber, string body)
    {
        SaveSMSToFile(phoneNumber,body);
    }

    private void SaveSMSToFile(string mobileNumber, string body)
    {
        /*implementation for saving SMS to a file*/
        Console.WriteLine("Mocking SMS using file to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

à ce point, nous peut modifier le code dans (UIHandler) pour utiliser la mise en œuvre concrète du service (MockSMSService) facilement comme ci-dessous:

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        ISMSService _SMSService = new MockSMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

nous avons obtenu beaucoup de flexibilité et mis en place une séparation des préoccupations dans notre code, mais nous devons quand même faire un changement sur la base du code pour passer entre les deux services de SMS. Nous devons donc mettre en œuvre " injection de dépendance ".

pour y parvenir, nous devons implémenter un changement à notre constructeur de classe (UIHandler) pour passer la dépendance à travers elle, en faisant cela, le code qui utilise le (UIHandler) peut déterminer quelle implémentation concrète de (ISMSService) utiliser:

public class UIHandler
{
    private readonly ISMSService _SMSService;

    public UIHandler(ISMSService SMSService)
    {
        _SMSService = SMSService;
    }

    public void SendConfirmationMsg(string mobileNumber)
    {
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

maintenant le formulaire D'UI qui parlera avec la classe (UIHandler) est responsable de passer quelle implémentation d'interface (ISMSService) à consommer. Cela signifie que nous avons inversé le contrôle, le (UIHandler) n'est plus responsable de décider mise en œuvre à utiliser, le code d'appel le fait. Nous avons mis en œuvre le principe " Inversion du contrôle qui DI en est un type.

le code du formulaire D'assurance-chômage sera le suivant:

class Program
{
    static void Main(string[] args)
    {
        ISMSService _SMSService = new MockSMSService(); // dependency

        UIHandler _UIHandler = new UIHandler(_SMSService);
        _UIHandler.SendConfirmationMsg("96279544480");

        Console.ReadLine();
    }
}

COI indique qu'une classe externe gérant les classes d'une application,et classes externes signifie un conteneur gère la dépendance entre la classe d'application. le concept de base de IOC est que le programmeur n'a pas besoin de créer vos objets mais de décrire comment ils devraient être créés.

les principales tâches effectuées par le conteneur IoC sont les suivantes: pour instancier la classe d'application. de configurer l'objet. pour assembler les dépendances entre les objets.

DI est le processus permettant de les dépendances d'un objet au moment de l'exécution en utilisant l'injection par mutateur ou le constructeur de l'injection.

IOC(Inversion du contrôleur): donner le contrôle au conteneur pour obtenir l'instance de l'objet est appelé Inversion du contrôle., signifie qu'au lieu de vous créez un objet en utilisant nouvel opérateur , laissez le conteneur faire cela pour vous.

DI(Dependency Injection): passer les paramètres requis(propriétés) de XML à un objet(dans la classe POJO) est appelé injection de dépendance.

COI (Inversion du contrôle) est essentiellement un concept de conception qui consiste à supprimer les dépendances et à les découpler pour rendre le flux non linéaire , et laisser le conteneur / ou une autre entité gérer l'approvisionnement en dépendances. Il suit en fait Hollywood principal "ne nous appelez pas nous vous appellerons". Résumant ainsi les différences.

Inversion de contrôle: - c'est un terme générique pour découpler les dépendances et déléguer leur provisionnement, et cela peut être mise en œuvre de plusieurs façons (événements, les délégués etc).

injection de dépendance: - DI est un sous-type de IOC et est mis en œuvre par injection du constructeur, injection de setter ou injection de méthode.

l'article suivant le décrit très clairement.

https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO

Inversion de contrôle est un principe générique de conception de l'architecture logicielle qui aide à créer des cadres logiciels réutilisables et modulaires faciles à entretenir.

il s'agit d'un principe de conception selon lequel le flux de commande est" reçu " de la bibliothèque Générique-écrite ou du code réutilisable.

pour mieux le comprendre, voyons comment nous codions dans nos premiers jours de codage. Dans les langues procédurales/traditionnelles, la logique contrôle généralement le flux de l'application et "appelle" le code générique ou réutilisable/les fonctions. Par exemple, dans une application simple sur Console, Mon flux de contrôle est contrôlé par les instructions de mon programme, ce qui peut inclure les appels à certaines fonctions générales réutilisables.

print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);

//More print and scan statements
<Do Something Interesting>

//Call a Library function to find the age (common code)
print Age

en revanche, avec IoC, les cadres sont le code réutilisable qui" appelle " la logique commerciale.

par exemple, dans un système basé sur windows, un cadre sera déjà être disponible pour créer des éléments D'interface utilisateur comme des boutons, des menus, des fenêtres et des boîtes de dialogue. Quand j'écris la logique d'affaires de mon application, ce sont les événements de framework qui appelleront mon code logique d'affaires (quand un événement est déclenché) et non le contraire.

bien que le code du framework ne soit pas conscient de ma logique d'affaires, il saura quand même comment appeler mon code. Ceci est réalisé en utilisant des événements / délégués, des callbacks, etc. Ici, le contrôle du débit est "inversé".

ainsi, au lieu de dépendre du flux de contrôle sur des objets liés statiquement, le flux dépend du Graphe de l'objet global et des relations entre les différents objets.

est un modèle qui met en œuvre le principe du CIO pour résoudre les dépendances des objets.

en termes plus simples, lorsque vous essayez d'écrire du code, vous créez et utilisez différentes classes. Une classe (Classe A) peut utiliser d'autres classes (Classe B et / ou D). Ainsi, les classes B Et D sont des dépendances de la classe A.

une analogie simple sera une voiture de classe. Une voiture peut dépendre d'autres classes comme le Moteur, les Pneus et plus.

injection de dépendance suggère qu'au lieu des classes dépendantes (Class Car ici) créant ses dépendances (Class Engine and class Tyre), la classe devrait être injectée avec l'instance concrète de la dépendance.

permet de comprendre avec un plus pratique exemple. Considérez que vous écrivez votre propre rédacteur de texte. Entre autres choses, vous pouvez avoir un correcteur d'orthographe qui fournit à l'utilisateur une facilité pour vérifier les fautes de frappe dans son texte. Une simple mise en œuvre d'un tel code peut être:

Class TextEditor
{

    //Lot of rocket science to create the Editor goes here

    EnglishSpellChecker objSpellCheck;
    String text;

    public void TextEditor()

    {   

        objSpellCheck = new EnglishSpellChecker();

    }

    public ArrayList <typos> CheckSpellings()
    {

        //return Typos;

    }

}

À première vue, tout semble rose. L'utilisateur écrira du texte. Le développeur capturera le texte et appellera la fonction CheckSpellings et trouvera une liste de fautes de frappe qu'il montrera à l'utilisateur.

Tout semble bien fonctionner jusqu'à ce qu'un beau jour où un utilisateur commence à écrire le français dans l'éditeur.

pour fournir le support pour plus de langues, nous avons besoin d'avoir plus de SpellCheckers. Probablement français, allemand, espagnol, etc.

ici, nous avons créé un code étroitement couplé avec"English" SpellChecker étant étroitement couplé avec notre classe TextEditor, ce qui signifie que notre classe TextEditor dépend de L'Anglais Spellchecker ou en d'autres termes EnglishSpellCheker est la dépendance de TextEditor. Nous devons supprimer cette dépendance. En outre, notre éditeur de texte a besoin d'un moyen de tenir la référence concrète de n'importe quel correcteur orthographique basé sur la discrétion du développeur au moment de l'exécution.

donc, comme nous l'avons vu dans L'introduction de DI, il suggère que la classe devrait être injectée avec ses dépendances. Ainsi, il devrait être de la responsabilité du code appelant d'Injecter toutes les dépendances à la classe/code appelée. Pour que nous puissions restructurer notre code as

interface ISpellChecker
{

    Arraylist<typos> CheckSpelling(string Text);

}

Class EnglishSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}



Class FrenchSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}

dans notre exemple, la classe TextEditor devrait recevoir L'instance concrète de type ISpellChecker.

maintenant, la dépendance peut être injectée dans le constructeur, une propriété publique ou une méthode.

essayons de changer notre classe en utilisant le constructeur DI. La nouvelle classe TextEditor ressemblera à quelque chose comme:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

de sorte que le code appelant, tout en créant l'éditeur de texte peut injecter le type de correcteur orthographique approprié à l'instance du TextEditor.

vous pouvez lire l'article complet ici

DI et CIO sont deux modèle de conception que se concentrant principalement sur la fourniture de couplage lâche entre les composants , ou simplement une manière de nous dissocier les classiques des liens de dépendance entre l'objet, de sorte que les objets ne sont pas trop serrés les uns aux autres.

avec les exemples suivants, j'essaie d'expliquer ces deux concepts.

Précédemment nous écrivons le code comme ceci

Public MyClass{
 DependentClass dependentObject
 /*
  At somewhere in our code we need to instantiate 
  the object with new operator  inorder to use it or perform some method.
  */ 
  dependentObject= new DependentClass();
  dependentObject.someMethod();
}

avec injection de dépendance, l'injecteur de dépendance s'occupera de l'instanciation des objets

Public MyClass{
 /* Dependency injector will instantiate object*/
 DependentClass dependentObject

 /*
  At somewhere in our code we perform some method. 
  The process of  instantiation will be handled by the dependency injector
 */ 

  dependentObject.someMethod();
}

le processus ci-dessus consistant à donner le contrôle à un autre (par exemple le conteneur) pour l'instanciation et l'injection peut être qualifié d'Inversion du contrôle et le processus dans lequel le conteneur IOC injecte la dépendance pour nous peut être qualifié d'injection de dépendance.

le CIO est le principe selon lequel le flux de contrôle d'un programme est inversé: au lieu de le programmeur de contrôler le flux d'un programme , le programme qui contrôle le débit en réduisant les frais généraux pour le programmeur.et le processus utilisé par le programme pour injecter la dépendance est appelé DI

les deux concepts travaillent ensemble nous fournissant une façon d'écrire beaucoup plus flexible, réutilisable, et le code encapsulé, qui en font des concepts importants dans la conception de solutions orientées objet.

également recommander à lire.

qu'est-ce que l'injection de dépendance?

Vous pouvez également consulter l'un de mes semblables réponse ici

différence entre L'Inversion du contrôle et L'Injection de dépendance

commençons par D DE SOLID et regardons DI et IoC du livre de Scott Millett "Professional ASP.NET Design Patterns":

Principe D'Inversion de dépendance (DIP)

le DIP consiste à isoler vos classes du béton implémentations et dépendent de classes abstraites ou interface. Il promeut le mantra du codage à une interface plutôt qu'un la mise en œuvre, qui augmente la flexibilité au sein d'un système s'assurer que vous n'êtes pas étroitement lié à une seule mise en œuvre.

injection de dépendance (DI) et Inversion du contrôle (IoC)

sont étroitement liés au principe di et au principe CIO. DI est la loi de la fourniture d'un faible niveau ou à la charge de la classe par l'intermédiaire d'un constructeur, méthode ou propriété. Utilisé en conjonction avec DI, ils les classes dépendantes peuvent être inversées aux interfaces ou aux classes abstraites cela conduira à des systèmes à couplage lâche qui sont très testables et facile à changer.

dans IoC , le flux de commande d'un système est inversé par rapport à la programmation procédurale. Un exemple de ceci est un CIO conteneur , dont le but est d'injecter des services dans le code client sans avoir le code client spécifiant le béton application. Le contrôle dans ce cas qui est inversé est l'acte du le client obtient le service.

Millett, C (2010). Professionnel ASP.NET Design Patterns. Wiley Publishing. 7-8.

//ICO , DI ,10 ans en arrière , c'était la façon que:

public class  AuditDAOImpl implements Audit{

    //dependency
    AuditDAO auditDAO = null;
        //Control of the AuditDAO is with AuditDAOImpl because its creating the object
    public AuditDAOImpl () {
        this.auditDAO = new AuditDAO ();
    }
}

maintenant avec le printemps 3,4 ou plus tard comme ci-dessous

public class  AuditDAOImpl implements Audit{

    //dependency

     //Now control is shifted to Spring. Container find the object and provide it. 
    @Autowired
    AuditDAO auditDAO = null;

}

dans l'ensemble la commande est inversée de l'ancien concept de code couplé aux cadres comme le ressort qui rend l'objet disponible. Donc C'est IOC pour autant que je sache et injection de dépendances comme vous le savez lorsque nous injectons l'objet dépendant dans un autre objet en utilisant le constructeur ou les setters . Injecter signifie en passant, comme un argument. Au printemps, nous avons une configuration basée sur XML et annotation où nous définissons l'objet bean et passons l'objet dépendant avec le style D'injection du constructeur ou du setter.

j'ai trouvé le meilleur exemple sur Dzone.com ce qui est vraiment utile pour comprendre la différence réelle entre IOC et DI

"le Cio est quand vous avez quelqu'un d'autre de créer des objets pour vous."Si au lieu d'écrire "nouveau" mot-clé (Par exemple, MyCode c=new MyCode())dans votre code, l'objet est créé par quelqu'un d'autre. Ce "quelqu'un d'autre" est normalement appelé un conteneur CIO. Cela signifie que nous transférons la responsabilité (contrôle )pour le conteneur pour obtenir instance de l'objet est appelé Inversion de Contrôle., moyens au lieu de vous créez l'objet en utilisant le nouvel opérateur, laissez le conteneur faire cela pour vous.

   DI(Dependency Injection):  Way of injecting properties to an object is 
   called 
  Dependency injection.
   We have three types of Dependency injection
    1)  Constructor Injection
    2)  Setter/Getter Injection
    3)  Interface Injection
   Spring will support only Constructor Injection and Setter/Getter Injection.

Lire l'article complet CIO et Lire L'article complet DI

1) DI est Enfant->obj dépend parent-obj. Le verbe dépend est important. 2) CIO de l'Enfant->obj effectuer en vertu d'une plate-forme. où la plateforme pourrait être école, université, cours de danse. Ici perform est une activité avec des implications différentes sous n'importe quel fournisseur de plate-forme.

exemple pratique:

//DI
child.getSchool();
//IOC
child.perform()// is a stub implemented by dance-school
child.flourish()// is a stub implemented by dance-school/school/

`

- AB

Inversion de la commande

Concepts De Base

voici une définition informelle du CIO: "le CIO, c'est quand quelqu'un d'autre crée des objets pour vous."Si au lieu d'écrire "nouveau" mot-clé dans votre code, l'objet est créé par quelqu'un d'autre. Ce "Quelqu'un d'autre" est normalement appelé un conteneur CIO.

cette simple explication illustre quelques idées:

1. on l'appelle IoC parce que le contrôle de l'objet est inversé. Il n'est pas le programmeur, mais quelqu'un d'autre qui a le contrôle de l'objet.
2. le COI est relatif en ce sens qu'il ne s'applique qu'à certains objets de la demande. Il peut donc y avoir CIO pour certains objets, tandis que d'autres sont sous le contrôle direct de programmeur.

Injection De Dépendance L'Injection de dépendances est devenue l'une des pierres angulaires des logiciels modernes l'ingénierie, car il est fondamental de permettre des tests appropriés. Pour le dire simplement, avoir DI est l'opposé d'avoir des dépendances codées.

une dépendance peut être injectée de plusieurs façons, comme un paramètre dans le constructeur ou par une méthode" set".