c# - valid - ¿Alguien puede explicar Microsoft Unity?

param name c#

Question

He estado leyendo los artículos en MSDN sobre Unity (Dependency Injection, Inversion of Control), pero creo que lo necesito explicado en términos simples (o ejemplos simples). Estoy familiarizado con el patrón de MVPC (lo usamos aquí), pero aún no puedo captar esta unidad, y creo que es el siguiente paso en el diseño de nuestra aplicación.

Answer 1

Acabo de ver los 30 minutos Unity Dependency Injection IoC Screencast de David Hayden y sentí que era una buena explicación con ejemplos. Aquí hay un fragmento de las notas del programa:

El screencast muestra varios usos comunes del Unity IoC, como:

• Crear tipos no en contenedor
• Registrando y resolviendo TypeMappings
• Registro y resolución de nombramientos de tipos con nombre
• Singletons, LifetimeManagers y ContainerControlledLifetimeManager
• Registrando instancias existentes
• Inyectar dependencias en instancias existentes
• Poblar el UnityContainer a través de App.config / Web.config
• Especificación de dependencias a través de API de inyección en lugar de Atributos de dependencia
• Usar contenedores anidados (padres-hijos)

Answer 2

Este tipo WilcoxTutorials ofrece una excelente demostración del contenedor Unity dirigido a principiantes.

Parte 1: http://www.youtube.com/watch?v=CWwe9Z0Gyew

Parte 2: http://www.youtube.com/watch?v=PsIbevgzQQE

¡En menos de media hora entenderás lo básico!

Answer 3

La unidad es un IoC. El objetivo de IoC es abstraer el cableado de las dependencias entre tipos fuera de los tipos mismos. Esto tiene un par de ventajas. En primer lugar, se realiza de forma centralizada, lo que significa que no es necesario cambiar una gran cantidad de código cuando cambian las dependencias (lo que puede ser el caso de las pruebas unitarias).

Además, si el cableado se realiza utilizando datos de configuración en lugar de código, en realidad puede volver a cablear las dependencias después de la implementación y así cambiar el comportamiento de la aplicación sin cambiar el código.

Answer 4

MSDN tiene una Guía del desarrollador de inyección de dependencias que usa Unity que puede ser útil.

La Guía del desarrollador comienza con los conceptos básicos de lo que es la inyección de dependencia y continúa con ejemplos de cómo usar Unity para la inyección de dependencias. A partir de febrero de 2014, la Guía del desarrollador cubre Unity 3.0, que se lanzó en abril de 2013.

Answer 5

Unity es solo un "contenedor" de IoC. Google StructureMap y pruébelo en su lugar. Me parece un poco más fácil de asimilar, cuando las cosas de IoC son nuevas para ti.

Básicamente, si entiendes IoC entiendes que lo que estás haciendo es invertir el control para cuando se crea un objeto.

Sin Ioc:

public class MyClass
{
   IMyService _myService; 

   public MyClass()
   {
      _myService = new SomeConcreteService();    
   }
}

Con contenedor IoC:

public class MyClass
{
   IMyService _myService; 

   public MyClass(IMyService myService)
   {
      _myService = myService;    
   }
}

Sin IoC, su clase que confía en IMyService tiene que actualizar una versión concreta del servicio para usar. Y eso es malo por varias razones (usted ha acoplado su clase a una versión específica concreta de IMyService, no puede probarla de manera unitaria, no puede cambiarla fácilmente, etc.)

Con un contenedor IoC "configura" el contenedor para resolver esas dependencias por usted. Entonces, con un esquema de inyección basado en el constructor, simplemente pasa la interfaz a la dependencia IMyService en el constructor. Cuando crea MyClass con su contenedor, su contenedor resolverá la dependencia de IMyService por usted.

Usando StructureMap, la configuración del contenedor se ve así:

StructureMapConfiguration.ForRequestedType<MyClass>().TheDefaultIsConcreteType<MyClass>();
StructureMapConfiguration.ForRequestedType<IMyService>().TheDefaultIsConcreteType<SomeConcreteService>();

Entonces, lo que ha hecho le dice al contenedor: "Cuando alguien solicite el servicio IMyService, entréguele una copia del servicio SomeConcrete". Y también ha especificado que cuando alguien solicita una MyClass, obtiene una MyClass concreta.

Eso es todo lo que hace un contenedor IoC. Pueden hacer más, pero ese es el objetivo: resuelven las dependencias por usted, por lo que no tiene que hacerlo (y no tiene que usar la palabra clave "nueva" en todo su código).

Paso final: cuando crees tu MyClass, harías esto:

var myClass = ObjectFactory.GetInstance<MyClass>();

Espero que ayude. No dude en enviarme un correo electrónico.

Answer 6

Unity es una biblioteca como muchas otras que le permite obtener una instancia de un tipo solicitado sin tener que crearlo usted mismo. Así que dado.

public interface ICalculator
{
    void Add(int a, int b);
}

public class Calculator : ICalculator
{
    public void Add(int a, int b)
    {
        return a + b;
    }
}

Utilizaría una biblioteca como Unity para registrar Calculadora que se devolverá cuando se solicite el tipo ICalculator aka IoC (Inversión de control) (este ejemplo es teórico, no técnicamente correcto).

IoCLlibrary.Register<ICalculator>.Return<Calculator>();

Entonces, cuando quieres una instancia de ICalculator, solo ...

Calculator calc = IoCLibrary.Resolve<ICalculator>();

Las bibliotecas de IoC generalmente se pueden configurar para mantener un singleton o crear una nueva instancia cada vez que se resuelve un tipo.

Ahora digamos que tienes una clase que depende de un ICalculator para estar presente que podrías haber ...

public class BankingSystem
{
    public BankingSystem(ICalculator calc)
    {
        _calc = calc;
    }

    private ICalculator _calc;
}

Y puede configurar la biblioteca para inyectar un objeto en el constructor cuando se crea.

Entonces DI o Inyección de Dependencia significa inyectar cualquier objeto que otro pueda requerir.