Inversión de control frente a inyección de dependencia

Según el artículo escrito por Martin Fowler, la inversión de control es el principio en el que se invierte el flujo de control de un programa: en lugar de que el programador controle el flujo de un programa, las fuentes externas (marco, servicios, otros componentes) lo controlan. Es como si conectamos algo a otra cosa. Mencionó un ejemplo sobre EJB 2.0:

Por ejemplo, la interfaz Session Bean define ejbRemove, ejbPassivate (almacenado en almacenamiento secundario) y ejbActivate (restaurado desde el estado pasivo). No puedes controlar cuándo se llaman estos métodos, solo lo que hacen. El contenedor nos llama, nosotros no lo llamamos.

Esto conduce a la diferencia entre el marco y la biblioteca:

La inversión de control es una parte clave de lo que hace que un marco sea diferente a una biblioteca. Una biblioteca es esencialmente un conjunto de funciones que puede llamar, actualmente organizadas en clases. Cada llamada hace un trabajo y devuelve el control al cliente.

Creo que el punto de vista de que DI es IOC, significa que la dependencia de un objeto está invertida: en lugar de controlar sus propias dependencias, el ciclo de vida ... algo más lo hace por ti. Pero, como me dijo sobre DI a mano, DI no es necesariamente IOC. Todavía podemos tener DI y no IOC.

Sin embargo, en este documento (de pococapsule, otro marco IOC para C / C ++), sugiere que debido a IOC y DI, los contenedores IOC y los marcos DI son mucho más superiores a J2EE, ya que J2EE mezcla el código del marco en los componentes. , por lo que no lo convierte en un objeto simple de Java / C ++ (POJO / POCO).

Inversión de contenedores de control distintos del patrón de inyección de dependencia (Enlace de archivo)

Lectura adicional para comprender cuál es el problema con el antiguo Marco de desarrollo basado en componentes, que conduce al segundo documento anterior: Por qué y qué de la inversión de control (Enlace de archivo)

Mi pregunta: ¿Qué es exactamente IOC y DI? Estoy confundido. Basado en pococapsule, IOC es algo más significativo que una simple inversión del control entre objetos o programadores y frameworks.

preguntado el 01 de julio de 11 a las 13:07

Aquí hay una buena reseña sobre el tema, IoC vs DI (Dependency Inject) vs SL (Service Locator): tinyurl.com/kk4be58 - Extracto de la URL: ¿IoC vs DI (inyección de dependencia)? IoC es el concepto general donde el control del flujo es Invertida del código del cliente al marco, que "hace algo por el cliente". SL (Service Locator) y DI (Dependency Injection) son dos patrones de diseño que se derivan de IoC. -

Para agregar mis dos centavos, si uno está interesado en cómo la inyección de dependencia puede ser útil en un tema de cafetería, he escrito un artículo sobre eso aquí: digigene.com/design-patterns/dependency-injection-coffeeshop -

Inversión de dependencia: depende de abstracciones, no de concreciones. Inversión de control: Principal vs Abstracción, y cómo el Principal es el pegamento de los sistemas. Estas son algunas buenas publicaciones que hablan de esto: coderstower.com/2019/03/26/… coderstower.com/2019/04/02/… coderstower.com/2019/04/09/… -

leer acerca de esto profundo, se aclarará todo martinfowler.com/articulos/… -

24 Respuestas

COI es un término genérico que significa que en lugar de que la aplicación llame a las implementaciones proporcionadas por un bibliotecas (también conocido como caja de herramientas ), La marco llama a las implementaciones proporcionadas por la aplicación.

DI es una forma de IoC, donde las implementaciones se pasan a un objeto a través de constructores / establecedores / búsquedas de servicios, de los que el objeto 'dependerá' para que se comporte correctamente.

IoC sin usar DI, por ejemplo, sería el patrón de plantilla porque la implementación solo se puede cambiar mediante la subclasificación.

Marcos de DI están diseñados para hacer uso de DI y pueden definir interfaces (o anotaciones en Java) para facilitar el paso de las implementaciones.

Contenedores de IoC son marcos DI que pueden funcionar fuera del lenguaje de programación. En algunos, puede configurar qué implementaciones usar en archivos de metadatos (por ejemplo, XML) que son menos invasivas. Con algunos, puede hacer IoC que normalmente sería imposible, como inyectar una implementación en cortes de puntos.

Ver también esto El artículo de Martin Fowler.

respondido 18 nov., 20:23

Gracias por la respuesta. Pero el otro artículo sugiere que con IOC, los contenedores IOC son mucho más superiores a EJB, mientras que Martin Fowler sugiere que EJB es un ejemplo típico de IOC. - Amumu

La gestión de EJB es realmente un ejemplo típico de IoC. Puede verlo en el hecho de que el ciclo de vida de un EJB es administrado por el contenedor, no por el programador. El programador no crea ni destruye una instancia de EJB porque el control se delega al servidor. Ese es el concepto de IoC: el código externo controla cuándo se llama a su código, que suele ser el inverso de lo que se hace la mayor parte del tiempo. - brandizzi

IoC es un término genérico que significa que en lugar de que la aplicación llame a los métodos en un marco, el marco llama a las implementaciones proporcionadas por la aplicación. ¿Puedes explicarlo más sobre esto? - Imad Alazani

aka Principio de Hollywood, 'no nos llames, te llamaremos'. Deja la invocación al marco en lugar de a la aplicación. - sala de garrett

@ImadAlazani, será mejor que leas el artículo que adjuntó Garrett, que es una discusión detallada sobre cómo invertir el control del código de la aplicación al marco. - MengT

En resumen, IoC es un término mucho más amplio que incluye, entre otros, DI

El término Inversión de control (IoC) originalmente significaba cualquier tipo de estilo de programación donde un marco general o tiempo de ejecución controlaba el flujo del programa.

Antes de que DI tuviera un nombre, la gente comenzó a referirse a los marcos que administran las dependencias como Inversión de Contenedores de Control, y pronto, el significado de IoC derivó gradualmente hacia ese significado particular: Inversión del Control sobre las Dependencias.

Inversión de control (IoC) significa que los objetos no crean otros objetos en los que se basan para hacer su trabajo. En su lugar, obtienen los objetos que necesitan de una fuente externa (por ejemplo, un archivo de configuración xml).

Inyección de dependencia (DI) significa que esto se hace sin la intervención del objeto, generalmente mediante un componente de marco que pasa los parámetros del constructor y establece las propiedades.

Respondido 18 ago 15, 08:08

Parece que IoC es solo otro término para el principio de inversión de dependencia, ¿no? - Todd Vance

@ToddVance - Sí, creo que IoC y DIP son lo mismo. DIP y DI no son lo mismo. IoC se puede hacer sin DI, pero DI no se puede hacer sin IoC. - eljay

@ToddVance - No, DIP e IoC no son sinónimos y no están relacionados. - tsmith

Ja, por eso estoy aquí en este hilo ... "Inversión de control frente a inyección de dependencia" - Todd Vance

enter image description here
fuente

COI (Inversión of Control): - Es un término genérico y se implementa de varias formas (eventos, delegados, etc.).

DI (Ddependencia Injection): - DI es un subtipo de IoC y es implementado por inyección de constructor, inyección de setter o inyección de interfaz.

Pero Spring solo admite los siguientes dos tipos:

  • Inyección de Setter
    • La DI basada en Setter se realiza llamando a métodos de establecimiento en los beans del usuario después de invocar un constructor sin argumentos o un método de fábrica estático sin argumentos para crear una instancia de su bean.
  • Inyección de constructor
    • La DI basada en constructores se realiza invocando un constructor con una serie de argumentos, cada uno representando a un colaborador. Con esto podemos validar que los beans inyectados no son nulos y fallan rápidamente (fallan en tiempo de compilación y no en tiempo de ejecución), por lo que al iniciar la aplicación en sí, obtenemos NullPointerException: bean does not exist. La inyección de constructor es la mejor práctica para inyectar dependencias.

Respondido el 21 de diciembre de 18 a las 16:12

no es correcto afirmar que Spring no admite la inyección de propiedades. Lo hace. Y es una mala práctica, estoy de acuerdo. - kekko12

La anotación Spring @Autowired es una forma de inyección de propiedad en mi opinión: Sajith

DI es un subconjunto de IoC

  • COI significa que los objetos no crean otros objetos en los que se basan para hacer su trabajo. En su lugar, obtienen los objetos que necesitan de un servicio externo (por ejemplo, un archivo xml o un servicio de aplicación única). 2 implementaciones de IoC que utilizo son DI y ServiceLocator.
  • DI significa que el principio de IoC de obtener un objeto dependiente se realiza sin utilizar objetos concretos, sino abstracciones (interfaces). Esto hace que la cadena de todos los componentes sea comprobable, ya que el componente de nivel superior no depende del componente de nivel inferior, solo de la interfaz. Los simulacros implementan estas interfaces.

Aquí hay algunas otras técnicas para lograr IoC.

Respondido el 12 de junio de 17 a las 08:06

No diría que IoC significa no crear objetos. Cuando llama no al método de clase directamente, sino al método de interfaz, esto es una inversión de control (ya que en este caso la persona que llama no depende del código de llamada) y no está relacionado con la creación de objetos en absoluto. Un ejemplo más de IoC son los eventos y los delegados: Evgeny Gorbovoy

IOC (inversión de control): Dar control al contenedor para obtener una instancia del objeto se llama Inversión de control, significa que en lugar de crear un objeto con el operador nuevo, deje que el contenedor lo haga por usted.

DI (inyección de dependencia): La forma de inyectar propiedades a un objeto se llama Inyección de dependencia.

Tenemos tres tipos de Inyección de dependencia:

  1. Inyección de constructor
  2. Inyección Setter / Getter
  3. Inyección de interfaz

Solo soportes de resorte Inyección de constructor y Inyección Setter / Getter.

contestado el 29 de mayo de 20 a las 13:05

Dado que todas las respuestas enfatizan en la teoría, me gustaría demostrar con un primer enfoque de ejemplo:

Supongamos que estamos creando una aplicación que contiene una función para enviar mensajes de confirmación SMS una vez que se ha enviado el pedido. Tendremos dos clases, una se encarga de enviar el SMS (SMSService), y otra responsable de capturar las entradas del usuario (UIHandler), nuestro código se verá a continuación:

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!");
    }
}

La implementación anterior no es incorrecta, pero hay algunos problemas:
-) Suponga que en el entorno de desarrollo, desea guardar los SMS enviados a un archivo de texto en lugar de utilizar la puerta de enlace SMS, para lograrlo; Terminaremos cambiando la implementación concreta de (SMSService) con otra implementación, estamos perdiendo flexibilidad y nos vemos obligados a reescribir el código en este caso.
-) Terminaremos mezclando responsabilidades de clases, nuestro (UIHandler) nunca debería saber sobre la implementación concreta de (SMSService), esto debería hacerse fuera de las clases usando “Interfaces”. Cuando esto se implemente, nos dará la capacidad de cambiar el comportamiento del sistema intercambiando el (SMSService) usado con otro servicio simulado que implementa la misma interfaz, este servicio guardará los SMS en un archivo de texto en lugar de enviarlos a mobileNumber.

Para solucionar los problemas anteriores, utilizamos interfaces que serán implementadas por nuestro (SMSService) y el nuevo (MockSMSService), básicamente la nueva interfaz (ISMSService) expondrá los mismos comportamientos de ambos servicios como el siguiente código:

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

Luego cambiaremos nuestra implementación (SMSService) para implementar la interfaz (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);
    }
}

Ahora podremos crear un nuevo servicio de simulación (MockSMSService) con una implementación totalmente diferente utilizando la misma interfaz:

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);
    }
}

En este punto, podemos cambiar el código en (UIHandler) para usar la implementación concreta del servicio (MockSMSService) fácilmente como se muestra a continuación:

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

Hemos logrado mucha flexibilidad e implementado la separación de preocupaciones en nuestro código, pero aún tenemos que hacer un cambio en la base del código para cambiar entre los dos servicios SMS. Entonces necesitamos implementar Inyección de dependencia.

Para lograr esto, necesitamos implementar un cambio en nuestro constructor de clase (UIHandler) para pasar la dependencia a través de él, al hacer esto, el código que usa el (UIHandler) puede determinar qué implementación concreta de (ISMSService) usar:

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!");
    }
}

Ahora, el formulario de interfaz de usuario que hablará con la clase (UIHandler) es responsable de pasar qué implementación de interfaz (ISMSService) consumir. Esto significa que hemos invertido el control, el (UIHandler) ya no es responsable de decidir qué implementación usar, el código de llamada sí lo hace. Hemos implementado el Inversión de control principio que DI es un tipo de él.

El código del formulario de la interfaz de usuario será el siguiente:

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

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

        Console.ReadLine();
    }
}

Respondido 24 Oct 17, 15:10

Gran explicación - ZiviMagia

En lugar de contrastar DI e IoC directamente, puede ser útil comenzar desde el principio: cada aplicación no trivial depende de otras piezas de código.

Entonces estoy escribiendo una clase MyClass, y necesito llamar a un método de YourService... de alguna manera necesito adquirir una instancia de YourService. La forma más sencilla y directa es crear una instancia yo mismo.

YourService service = new YourServiceImpl();

La instanciación directa es la forma tradicional (procedimental) de adquirir una dependencia. Pero tiene una serie de inconvenientes, incluido el acoplamiento estrecho de MyClass a YourServiceImpl, lo que hace que mi código sea difícil de cambiar y difícil de probar. MyClass no le importa cuál sea la implementación de YourService parece, entonces MyClass no quiere ser responsable de instanciarlo.

preferiría invertir esa responsabilidad de MyClass a algo afuera MyClass. La forma más sencilla de hacerlo es simplemente mover la llamada de instanciación (new YourServiceImpl();) en alguna otra clase. Podría nombrar a esta otra clase Localizador, Fábrica o cualquier otro nombre; pero el punto es que MyClass ya no es responsable de YourServiceImpl. He invertido esa dependencia. Excelente.

El problema es, MyClass sigue siendo responsable de realizar la llamada al localizador / fábrica / lo que sea. Como todo lo que he hecho para invertir la dependencia es insertar un intermediario, ahora estoy acoplado al intermediario (incluso si no estoy acoplado a los objetos concretos que me da el intermediario).

Realmente no me importa de dónde provienen mis dependencias, por lo que prefiero no ser responsable de hacer las llamadas para recuperarlas. Invertir la dependencia en sí no fue suficiente. Quiero invertir el control de todo el proceso.

Lo que necesito es una pieza de código totalmente separada que MyClass se conecta a (llámalo marco). Entonces, la única responsabilidad que me queda es declarar mi dependencia de YourService. El marco puede encargarse de averiguar dónde, cuándo y cómo obtener una instancia, y simplemente dar MyClass lo que necesita. Y la mejor parte es que MyClass no necesita saber sobre el marco. El marco puede tener el control de este proceso de cableado de dependencia. Ahora he invertido el control (además de invertir las dependencias).

Hay diferentes formas de conectar MyClass en un marco. La inyección es uno de esos mecanismos mediante el cual simplemente declaro un campo o parámetro que espero que proporcione un marco, generalmente cuando crea una instancia MyClass.

Creo que la jerarquía de relaciones entre todos estos conceptos es un poco más compleja de lo que muestran otros diagramas de este hilo; pero la idea básica es que se trata de una relación jerárquica. Creo que esto se sincroniza con DIP en la naturaleza.

Jerarquía de adquisición de dependencias

Respondido el 06 de enero de 21 a las 00:01

Pero la documentación de primavera dice que son iguales.

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

En la primera línea "IoC también se conoce como inyección de dependencia (DI)".

Respondido 03 ago 15, 12:08

Supongo que lo que estaban tratando de abordar es que DI es un sabor muy utilizado del patrón de diseño de IoC que casi se puede llamar IoC también conocido como DI, a menos que la documentación tenga alguna referencia explícita que sugiera lo contrario. - ha9u63ar

"IoC también se conoce como inyección de dependencia (DI)" ... ¡plumas de caballo! - Innovador

IoC se puede llamar principio de diseño y DI es su implementación. En ambos casos, la responsabilidad de administrar los Objetos se transfiere al contenedor de resorte en lugar de invertir el control. - Tariq Abbas

Debido a esta declaración, el candidato de la entrevista se volvió loco defendiendo esta declaración, porque no tenía otra fuente de información. Bastante engañoso ... - Praytico

COI - La inversión de control es un término genérico, independiente del lenguaje, en realidad no se trata de crear los objetos sino de describir en qué objeto de moda se está creando.

DI - Inyección de dependencias es un término concreto, en el que proporcionamos dependencias del objeto en tiempo de ejecución mediante el uso de diferentes técnicas de inyección, a saber. Setter Injection, Constructor Injection o por Interface Injection.

Respondido el 18 de Septiembre de 15 a las 07:09

DI y COI son dos patrón de diseño que se centra principalmente en proporcionar acoplamiento flojo entre componentes, o simplemente una forma en la que desacoplamos las relaciones de dependencia convencionales entre objetos para que los objetos no estén apretados entre sí.

Con los siguientes ejemplos, intento explicar ambos conceptos.

Anteriormente estamos escribiendo código como este

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();
}

Con la inyección de dependencia, el inyector de dependencia se encargará de la creación de instancias de objetos

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();
}

El proceso anterior de ceder el control a algún otro (por ejemplo, el contenedor) para la instanciación e inyección puede denominarse Inversión de control y el proceso en el que el contenedor IOC inyecta la dependencia por nosotros puede denominarse inyección de dependencia.

IOC es el principio en el que se invierte el flujo de control de un programa: en lugar de que el programador controle el flujo de un programa, el programa controla el flujo reduciendo la sobrecarga para el programador. el proceso utilizado por el programa para inyectar dependencia se denomina DI

Los dos conceptos trabajan juntos, lo que nos proporciona una forma de escribir código mucho más flexible, reutilizable y encapsulado, lo que los convierte en conceptos importantes en el diseño de soluciones orientadas a objetos.

También recomiendo leer.

¿Qué es la inyección de dependencia?

También puede consultar una de mis respuestas similares aquí.

Diferencia entre inversión de control e inyección de dependencia

Respondido el 27 de Septiembre de 18 a las 02:09

IOC (Inversión de control): Dar control al contenedor para obtener una instancia de objeto se llama Inversión de Control. Significa que en lugar de estar creando un objeto usando nuevo operador, deja que el contenedor haga eso por ti.

DI (inyección de dependencia): Pasar los parámetros requeridos (propiedades) de XML a un objeto (en POJO CLASS) se llama inyección de dependencia.

Respondido el 28 de enero de 19 a las 19:01

La inversión de control es un paradigma de diseño con el objetivo de dar más control a los componentes específicos de su aplicación, los que hacen el trabajo.
La inyección de dependencia es un patrón que se utiliza para crear instancias de objetos en los que se basan otros objetos sin saber en el momento de la compilación qué clase se utilizará para proporcionar esa funcionalidad.

Existen varias técnicas básicas para implementar la inversión de control. Estos son:

  • Usando un patrón de fábrica
  • Usar un patrón de localizador de servicios
  • Usando una inyección de dependencia de cualquier tipo dado a continuación:

    1). Una inyección de constructor
    2). Una inyección de setter
    3). Una inyección de interfaz

respondido 15 mar '17, 07:03

La inversión de control es un principio de diseño genérico de la arquitectura de software que ayuda a crear marcos de software modulares y reutilizables que son fáciles de mantener.

Es un principio de diseño en el que el flujo de control se "recibe" de la biblioteca genérica escrita o del código reutilizable.

Para entenderlo mejor, veamos cómo solíamos codificar en nuestros primeros días de codificación. En los lenguajes procedimentales / tradicionales, la lógica empresarial generalmente controla el flujo de la aplicación y "Llama" al código / funciones genéricos o reutilizables. Por ejemplo, en una aplicación de consola simple, mi flujo de control está controlado por las instrucciones de mi programa, que pueden incluir las llamadas a algunas funciones generales reutilizables.

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 contraste, con IoC, los Frameworks son el código reutilizable que "llama" a la lógica empresarial.

Por ejemplo, en un sistema basado en Windows, ya estará disponible un marco para crear elementos de interfaz de usuario como botones, menús, ventanas y cuadros de diálogo. Cuando escribo la lógica de negocios de mi aplicación, serían los eventos del framework los que llamarían a mi código de lógica de negocios (cuando se dispara un evento) y NO lo contrario.

Aunque el código del marco no conoce mi lógica empresarial, aún sabrá cómo llamar a mi código. Esto se logra mediante eventos / delegados, devoluciones de llamada, etc. Aquí el control de flujo está "Invertido".

Entonces, en lugar de depender del flujo de control en objetos vinculados estáticamente, el flujo depende del gráfico de objeto general y las relaciones entre diferentes objetos.

La inyección de dependencia es un patrón de diseño que implementa el principio de IoC para resolver dependencias de objetos.

En palabras más simples, cuando intentas escribir código, estarás creando y usando diferentes clases. Una clase (Clase A) puede utilizar otras clases (Clase B y / o D). Entonces, las clases B y D son dependencias de la clase A.

Una simple analogía sería un auto de clase. Un automóvil puede depender de otras clases como motor, neumáticos y más.

La inyección de dependencia sugiere que en lugar de que las clases dependientes (Class Car aquí) creen sus dependencias (Class Engine y class Tire), la clase debería inyectarse con la instancia concreta de la dependencia.

Entendamos con un ejemplo más práctico. Considere que está escribiendo su propio TextEditor. Entre otras cosas, puede tener un corrector ortográfico que le brinde al usuario la posibilidad de verificar los errores tipográficos en su texto. Una implementación simple de dicho código puede ser:

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;

    }

}

A primera vista, todo parece color de rosa. El usuario escribirá algún texto. El desarrollador capturará el texto y llamará a la función CheckSpellings y encontrará una lista de errores tipográficos que le mostrará al usuario.

Todo parece funcionar muy bien hasta que un buen día un usuario comienza a escribir en francés en el Editor.

Para proporcionar soporte para más idiomas, necesitamos tener más correctores ortográficos. Probablemente francés, alemán, español, etc.

Aquí, hemos creado un código estrechamente acoplado con "English" SpellChecker estrechamente acoplado con nuestra clase TextEditor, lo que significa que nuestra clase TextEditor depende de EnglishSpellChecker o, en otras palabras, EnglishSpellCheker es la dependencia de TextEditor. Necesitamos eliminar esta dependencia. Además, nuestro editor de texto necesita una forma de contener la referencia concreta de cualquier corrector ortográfico según el criterio del desarrollador en tiempo de ejecución.

Entonces, como vimos en la introducción de DI, sugiere que la clase debe inyectarse con sus dependencias. Por lo tanto, debería ser responsabilidad del código de llamada inyectar todas las dependencias a la clase / código llamado. Entonces podemos reestructurar nuestro código como

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.

    }

}

En nuestro ejemplo, la clase TextEditor debería recibir la instancia concreta del tipo ISpellChecker.

Ahora, la dependencia se puede inyectar en Constructor, una Propiedad Pública o un método.

Intentemos cambiar nuestra clase usando Constructor DI. La clase TextEditor modificada se verá así:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

Para que el código de llamada, mientras crea el editor de texto, pueda inyectar el tipo de corrector ortográfico apropiado en la instancia del TextEditor.

Puedes leer el artículo completo aquí

Respondido el 14 de junio de 18 a las 17:06

COI indica que las clases externas administran las clases de una aplicación, y las clases externas significan que un contenedor administra la dependencia entre las clases de aplicación. concepto básico de COI es que el programador no necesita crear sus objetos, sino describir cómo deben crearse.

Las principales tareas que realiza el contenedor IoC son: para crear una instancia de la clase de aplicación. para configurar el objeto. para ensamblar las dependencias entre los objetos.

DI es el proceso de proporcionar las dependencias de un objeto en tiempo de ejecución mediante la inyección de setter o la inyección de constructor.

Respondido 28 Jul 15, 10:07

IOC (Inversión de control) es básicamente un concepto de patrón de diseño para eliminar dependencias y desacoplarlas para hacer que el flujo no sea lineal, y dejar que el contenedor / u otra entidad administre el aprovisionamiento de dependencias. De hecho, sigue al director de Hollywood: "No nos llames, te llamaremos". Así que resumiendo las diferencias.

Inversión de control: - Es un término genérico para desacoplar las dependencias y delegar su aprovisionamiento, y esto se puede implementar de varias formas (eventos, delegados, etc.).

Inyección de dependencia: - DI es un subtipo de IOC y se implementa mediante inyección de constructor, inyección de setter o inyección de método.

El siguiente artículo describe esto muy claramente.

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

Respondido 30 Oct 17, 02:10

Creo que la idea se puede demostrar claramente sin entrar en malas hierbas orientadas a objetos, que parecen confundir la idea.

// dependency injection
function doSomething(dependency) {
    // do something with your dependency
}

// in contrast to creating your dependencies yourself
function doSomething() {
    dependency = getDependencySomehow()
}

// inversion of control
application = makeApp(authenticate, handleRequest, sendResponse)
application.run(getRequest())

// in contrast to direct control or a "library" style
application = makeApp()
request = application.getRequest()

if (application.authenticate(request.creds)) {
    response = application.handleRequest(request)
    application.sendResponse(response)
}

Si inclina la cabeza y entrecierra los ojos, verá que DI es una implementación particular de IoC con preocupaciones específicas. En lugar de inyectar modelos y comportamientos en un marco de aplicación u operación de orden superior, está inyectando variables en una función u objeto.

respondido 07 nov., 19:19

COI - DIP - DI

  1. Inversión de control (IOC)
  2. Principio de inversión de dependencia (DIP)
  3. Inyección de dependencia (DI)

1- COI: principio abstracto que describe un aspecto de algunos diseños de arquitectura de software en el que el flujo de control de un sistema se invierte en comparación con la programación procedimental.

2-DIP: es el principio de Programación Orientada a Objetos (OOP) (D de SOLID).

3-DI: es un patrón de diseño de software que implementa la inversión de control y permite que el diseño de un programa siga el principio de inversión de dependencia.

enter image description here IOC y DIP son dos conjuntos disjuntos y DIP es el superconjunto de DI, localizador de servicios y algunos otros patrones

respondido 24 nov., 20:10

Comencemos con D de SOLID y observemos DI e IoC del libro de Scott Millett "Professional ASP.NET Design Patterns":

Principio de inversión de dependencia (DIP)

La DIP se trata de aislar sus clases de implementaciones concretas y hacer que dependan de clases o interfaces abstractas. Promueve el mantra de codificar en una interfaz en lugar de una implementación, lo que aumenta la flexibilidad dentro de un sistema al garantizar que no esté estrechamente vinculado a una implementación.

Inyección de dependencia (DI) e inversión de control (IoC)

Estrechamente vinculados al DIP están el principio DI y el principio IoC. DI es el acto de suministrar una clase dependiente o de bajo nivel a través de un constructor, método o propiedad. Utilizadas junto con DI, estas clases dependientes se pueden invertir en interfaces o clases abstractas que conducirán a sistemas poco acoplados que son altamente probables y fáciles de cambiar.

In COI, el flujo de control de un sistema se invierte en comparación con la programación de procedimientos. Un ejemplo de esto es un Contenedor de IoC, cuyo propósito es inyectar servicios en el código del cliente sin que el código del cliente especifique la implementación concreta. El control en esta instancia que se invierte es el acto del cliente que obtiene el servicio.

Millett, C (2010). Patrones de diseño ASP.NET profesionales. Wiley Publishing. 7-8.

Respondido el 20 de junio de 20 a las 10:06

// ICO, DI, hace 10 años, así era:

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 ();
    }
}

Ahora con Spring 3,4 o más reciente es como a continuación

public class  AuditDAOImpl implements Audit{

    //dependency

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

}

En general, el control se invierte del antiguo concepto de código acoplado a los marcos como Spring, que hace que el objeto esté disponible. Por lo que yo sé, eso es IOC y la inyección de dependencia, como saben, cuando inyectamos el objeto dependiente en otro objeto usando Constructor o setters. Inyectar básicamente significa pasarlo como argumento. En primavera, tenemos una configuración basada en XML y anotaciones donde definimos el objeto bean y pasamos el objeto dependiente con el estilo de inyección Constructor o setter.

Respondido el 22 de Septiembre de 17 a las 19:09

Encontré el mejor ejemplo en Dzone.com que es realmente útil para comprender la diferencia real entre IOC y DI

"IoC es cuando alguien más crea objetos por usted". Entonces, en lugar de escribir una palabra clave "nueva" (por ejemplo, MyCode c = new MyCode ()) en su código, el objeto es creado por otra persona. Este "alguien más" se denomina normalmente contenedor de IoC. Significa que entregamos la responsabilidad (control) al contenedor para obtener la instancia del objeto que se llama Inversión de control., Significa que en lugar de que usted esté creando un objeto usando un nuevo operador, deje que el contenedor lo haga por usted.

   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.

Leer artículo completo COI y Leer artículo completo DI

Respondido 16 Abr '18, 14:04

1) DI es Child-> obj depende de parent-obj. El verbo depende es importante. 2) COI es Niño-> obj actuar bajo una plataforma. donde la plataforma podría ser la escuela, la universidad, la clase de baile. Aquí realizar es una actividad con diferente implicación bajo cualquier proveedor de plataforma.

ejemplo práctico: `

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

`

-AB

contestado el 17 de mayo de 18 a las 17:05

En cuanto a esta pregunta, diría que la wiki ya ha proporcionado explicaciones detalladas y fáciles de entender. Solo citaré lo más significativo aquí.

Implementación de IoC

En la programación orientada a objetos, existen varias técnicas básicas para implementar la inversión de control. Estos son:

  1. Usar un patrón de localizador de servicios Usar inyección de dependencia, por ejemplo Inyección de constructor Inyección de parámetros Inyección de setter Inyección de interfaz;
  2. Usando una búsqueda contextualizada;
  3. Usando patrón de diseño de método de plantilla;
  4. Usando el patrón de diseño de estrategia

En cuanto a los Inyección de dependencia

La inyección de dependencias es una técnica mediante la cual un objeto (o método estático) proporciona las dependencias de otro objeto. Una dependencia es un objeto que se puede utilizar (un servicio). Una inyección es el paso de una dependencia a un objeto dependiente (un cliente) que lo usaría.

Respondido 07 Abr '19, 07:04

El concepto de IoC se escuchó inicialmente durante la era de la programación procedimental. Por lo tanto, desde un contexto histórico, IoC habló de inversión de la propiedad de control-flujo es decir, quién tiene la responsabilidad de invocar las funciones en el orden deseado, ya sean las funciones en sí mismas o si debe invertirlas en alguna entidad externa.

Sin embargo, una vez que surgió la POO, la gente empezó a hablar de IoC en el contexto de la POO, donde las aplicaciones se preocupan por la creación de objetos y sus relaciones, además del flujo de control. Tales aplicaciones querían invertir la propiedad de la creación de objetos (en lugar del flujo de control) y requirió un contenedor que sea responsable de la creación de objetos, el ciclo de vida del objeto y la inyección de dependencias de los objetos de la aplicación, eliminando así los objetos de la aplicación de la creación de otros objetos concretos.

En ese sentido DI no es lo mismo que IoC, ya que no se trata de controlar el flujo, sin embargo, una especie de Io *, es decir, inversión de la propiedad de la creación de objetos.

¿Qué hay de malo en mi forma de explicar DI e IoC?

Respondido 20 Jul 19, 20:07

DIP frente a DI frente a IoC

[Principio de inversión de dependencia (DIP)] es una parte de SOLID[Acerca de] que te piden que uses abstracción en lugar de realizaciones

Inyección de dependencia (DI) - use agregación en lugar de composición[Acerca de] En este caso, el objeto externo es responsable de la lógica interna. Lo que le permite tener un enfoque más dinámico y comprobable.

class A {
  B b

  //injecting B via constructor 
  init(b: B) {
     self.b = b
  }
}

Inversión de control (IoC) definición de muy alto nivel que tiene más que ver con el control del flujo. El mejor ejemplo es Inversion of Control(IoC) Container or Framework[Acerca de]. Por ejemplo, GUI, que es Framework donde no tiene un control, todo lo que puede hacer es implementar la interfaz de Framework, que se llamará cuando suceda alguna acción en el Framework. Por lo tanto, el control se transfiere de su aplicación al marco que se está utilizando

INMERSIÓN + DI

class A {
  IB ib

  init(ib: IB) {
     self.ib = ib
  }
}

También puedes lograrlo usando:

Ejemplo más complejo

Regla de dependencia en estructura multicapa / módulo

Pseudocódigo:

interface InterfaceInputPort {
    func input()
}

interface InterfaceOutputPort {
    func output()
}

class A: InterfaceOutputPort {

    let inputPort = B(outputPort: self)

    func output() {
        print("output")
    }
}

class B: InterfaceInputPort {
    let outputPort: InterfaceOutputPort

    init(outputPort: InterfaceOutputPort) {
        self.outputPort = outputPort
    }

    func input() {
        print("input")
    }
}

contestado el 05 de mayo de 21 a las 14:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.