Alguém pode explicar Microsoft Unity?

votos
120

Estive lendo os artigos sobre MSDN sobre Unity (injeção de dependência, inversão de controle), mas acho que eu preciso que ele explicou em termos simples (ou exemplos simples). Estou familiarizado com o padrão MVPC (usamos aqui), mas eu simplesmente não consigo realmente entender essa coisa Unity ainda, e eu acho que é o próximo passo em nosso design do aplicativo.

Publicado 03/03/2009 em 21:54
fonte usuário
Em outras línguas...                            


8 respostas

votos
140

Unidade é apenas um "container" IoC. Google StructureMap e experimentá-lo em seu lugar. Um pouco mais fácil de Grokar, penso eu, quando o material IoC é novo para você.

Basicamente, se você entender IoC então você entende que o que você está fazendo é invertendo o controle para quando um objeto é criado.

Sem Ioc:

public class MyClass
{
   IMyService _myService; 

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

Com contêiner IoC:

public class MyClass
{
   IMyService _myService; 

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

Sem IoC, sua classe que se baseia na IMyService tem de novo-up uma versão concreta do serviço para usar. E isso é ruim para uma série de razões (que você acoplado a sua classe para uma versão concreta específica do IMyService, você não pode unidade de testá-lo facilmente, você não pode mudá-lo facilmente, etc.)

Com um contêiner IoC você "configurar" o recipiente para resolver essas dependências para você. Assim, com um esquema de injeção à base de construtor, você apenas passar a interface para a dependência IMyService para o construtor. Quando você cria o MyClass com o seu recipiente, o recipiente irá resolver a dependência IMyService para você.

Usando StructureMap, configurando o recipiente parecido com este:

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

Então, o que você fez é contada do recipiente, "Quando alguém solicita o IMyService, dar-lhes uma cópia do SomeConcreteService." E você também tenha especificado que quando alguém pede um MyClass, que recebem uma MyClass concreto.

Isso é tudo um contêiner IoC realmente faz. Eles podem fazer mais, mas isso é o impulso dela - eles resolver as dependências para você, para que você não tem que (e você não tem que usar a "nova" palavra-chave em todo o seu código).

Etapa final: quando você criar o seu MyClass, você faria isso:

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

Espero que ajude. Fique a vontade para me mandar um e-mail.

Respondeu 03/03/2009 em 22:02
fonte usuário

votos
28

A unidade é uma biblioteca como muitos outros que lhe permite obter uma instância de um tipo solicitado sem ter que criá-lo. Então dado.

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

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

Você usaria uma biblioteca como Unidade de registrar Calculator a ser devolvido quando o tipo ICalculator é solicitada aka IoC (Inversão de Controle) (este exemplo é teórica, não tecnicamente correto).

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

Agora, quando você quer uma instância de um ICalculator você só ...

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

bibliotecas IoC geralmente pode ser configurado para realizar uma única ou criar uma nova instância cada vez que você resolver um tipo.

Agora vamos dizer que você tem uma classe que se baseia em uma ICalculator estar presente você poderia ter ..

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

    private ICalculator _calc;
}

E você pode configurar a biblioteca para injetar um objeto para o construtor quando ele é criado.

Então DI ou injeção de dependência significa para injetar qualquer objeto outro pode exigir.

Respondeu 03/03/2009 em 22:05
fonte usuário

votos
8

A unidade é um IoC. O ponto de COI é abstrair a fiação de dependências entre tipos fora dos próprios tipos. Isto tem algumas vantagens. Em primeiro lugar, é feita de forma centralizada que significa que você não tem que mudar um monte de código quando dependências mudar (que pode ser o caso de testes de unidade).

Além disso, se a fiação é feita usando os dados de configuração em vez de código, você pode realmente reprogramar as dependências após a implantação e, assim, mudar o comportamento do aplicativo sem alterar o código.

Respondeu 03/03/2009 em 23:33
fonte usuário

votos
35

Eu só assisti a 30 minutos Unity Dependency Injection IoC Screencast por David Hayden e senti que era uma boa explicação com exemplos. Aqui está um trecho do show notas:

O screencast mostra vários usos comuns da Unidade COI, tais como:

  • Criação de tipos de fora do depósito
  • Registrar e Resolvendo TypeMappings
  • Registrar e Resolvendo TypeMappings nomeados
  • Singletons, LifetimeManagers, eo ContainerControlledLifetimeManager
  • Registrar instâncias existentes
  • Injectar dependências em instâncias existentes
  • Preenchendo a UnityContainer através config.XML / web.config
  • Especificando as dependências através da injeção API em oposição a Atributos de dependência
  • Usando aninhadas Containers (pai-filho)
Respondeu 25/05/2009 em 23:52
fonte usuário

votos
21

Esse cara WilcoxTutorials dá uma excelente demonstração do recipiente Unity que é destinado a iniciantes.

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

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

Em menos de meia hora e você vai entender o básico!

Respondeu 09/05/2013 em 03:52
fonte usuário

votos
4

MSDN tem um guia para Dependency Injection do desenvolvedor Usando Unity que podem ser úteis.

Guia do desenvolvedor começa com o básico do que a injeção de dependência é, e continua com exemplos de como usar o Unity para injeção de dependência. A partir do fevereiro 2014 Guia do desenvolvedor cobre Unity 3.0, que foi lançado em Abril de 2013.

Respondeu 11/02/2014 em 18:24
fonte usuário

votos
1

Estou cobrindo a maior parte dos exemplos de Dependency Injection em ASP.NET Web API 2

public interface IShape
{
    string Name { get; set; }
}

public class NoShape : IShape
{
    public string Name { get; set; } = "I have No Shape";
}

public class Circle : IShape
{
    public string Name { get; set; } = "Circle";
}

public class Rectangle : IShape
{
    public Rectangle(string name)
    {
        this.Name = name;
    }

    public string Name { get; set; } = "Rectangle";
}

Em DIAutoV2Controller.cs mecanismo de injecção automático é utilizada

[RoutePrefix("api/v2/DIAutoExample")]
public class DIAutoV2Controller : ApiController
{
    private string ConstructorInjected;
    private string MethodInjected1;
    private string MethodInjected2;
    private string MethodInjected3;

    [Dependency]
    public IShape NoShape { get; set; }

    [Dependency("Circle")]
    public IShape ShapeCircle { get; set; }

    [Dependency("Rectangle")]
    public IShape ShapeRectangle { get; set; }

    [Dependency("PiValueExample1")]
    public double PiValue { get; set; }

    [InjectionConstructor]
    public DIAutoV2Controller([Dependency("Circle")]IShape shape1, [Dependency("Rectangle")]IShape shape2, IShape shape3)
    {
        this.ConstructorInjected = shape1.Name + " & " + shape2.Name + " & " + shape3.Name;
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize()
    {
        this.MethodInjected1 = "Default Initialize done";
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize2([Dependency("Circle")]IShape shape1)
    {
        this.MethodInjected2 = shape1.Name;
    }

    [NonAction]
    [InjectionMethod]
    public void Initialize3(IShape shape1)
    {
        this.MethodInjected3 = shape1.Name;
    }

    [HttpGet]
    [Route("constructorinjection")]
    public string constructorinjection()
    {
        return "Constructor Injected: " + this.ConstructorInjected;
    }

    [HttpGet]
    [Route("GetNoShape")]
    public string GetNoShape()
    {
        return "Property Injected: " + this.NoShape.Name;
    }

    [HttpGet]
    [Route("GetShapeCircle")]
    public string GetShapeCircle()
    {
        return "Property Injected: " + this.ShapeCircle.Name;
    }

    [HttpGet]
    [Route("GetShapeRectangle")]
    public string GetShapeRectangle()
    {
        return "Property Injected: " + this.ShapeRectangle.Name;
    }

    [HttpGet]
    [Route("GetPiValue")]
    public string GetPiValue()
    {
        return "Property Injected: " + this.PiValue;
    }

    [HttpGet]
    [Route("MethodInjected1")]
    public string InjectionMethod1()
    {
        return "Method Injected: " + this.MethodInjected1;
    }

    [HttpGet]
    [Route("MethodInjected2")]
    public string InjectionMethod2()
    {
        return "Method Injected: " + this.MethodInjected2;
    }

    [HttpGet]
    [Route("MethodInjected3")]
    public string InjectionMethod3()
    {
        return "Method Injected: " + this.MethodInjected3;
    }
}

Em DIV2Controller.cs tudo será injetado a partir da classe de dependência de configuração Resolver

[RoutePrefix("api/v2/DIExample")]
public class DIV2Controller : ApiController
{
    private string ConstructorInjected;
    private string MethodInjected1;
    private string MethodInjected2;
    public string MyPropertyName { get; set; }
    public double PiValue1 { get; set; }
    public double PiValue2 { get; set; }
    public IShape Shape { get; set; }

    // MethodInjected
    [NonAction]
    public void Initialize()
    {
        this.MethodInjected1 = "Default Initialize done";
    }

    // MethodInjected
    [NonAction]
    public void Initialize2(string myproperty1, IShape shape1, string myproperty2, IShape shape2)
    {
        this.MethodInjected2 = myproperty1 + " & " + shape1.Name + " & " + myproperty2 + " & " + shape2.Name;
    }

    public DIV2Controller(string myproperty1, IShape shape1, string myproperty2, IShape shape2)
    {
        this.ConstructorInjected = myproperty1 + " & " + shape1.Name + " & " + myproperty2 + " & " + shape2.Name;
    }

    [HttpGet]
    [Route("constructorinjection")]
    public string constructorinjection()
    {
        return "Constructor Injected: " + this.ConstructorInjected;
    }

    [HttpGet]
    [Route("PropertyInjected")]
    public string InjectionProperty()
    {
        return "Property Injected: " + this.MyPropertyName;
    }

    [HttpGet]
    [Route("GetPiValue1")]
    public string GetPiValue1()
    {
        return "Property Injected: " + this.PiValue1;
    }

    [HttpGet]
    [Route("GetPiValue2")]
    public string GetPiValue2()
    {
        return "Property Injected: " + this.PiValue2;
    }

    [HttpGet]
    [Route("GetShape")]
    public string GetShape()
    {
        return "Property Injected: " + this.Shape.Name;
    }

    [HttpGet]
    [Route("MethodInjected1")]
    public string InjectionMethod1()
    {
        return "Method Injected: " + this.MethodInjected1;
    }

    [HttpGet]
    [Route("MethodInjected2")]
    public string InjectionMethod2()
    {
        return "Method Injected: " + this.MethodInjected2;
    }
}

Configurando o Dependência Resolver

public static void Register(HttpConfiguration config)
{
    var container = new UnityContainer();
    RegisterInterfaces(container);
    config.DependencyResolver = new UnityResolver(container);

    // Other Web API configuration not shown.
}

private static void RegisterInterfaces(UnityContainer container)
{
    var dbContext = new SchoolDbContext();
    // Registration with constructor injection
    container.RegisterType<IStudentRepository, StudentRepository>(new InjectionConstructor(dbContext));
    container.RegisterType<ICourseRepository, CourseRepository>(new InjectionConstructor(dbContext));

    // Set constant/default value of Pi = 3.141 
    container.RegisterInstance<double>("PiValueExample1", 3.141);
    container.RegisterInstance<double>("PiValueExample2", 3.14);

    // without a name
    container.RegisterInstance<IShape>(new NoShape());

    // with circle name
    container.RegisterType<IShape, Circle>("Circle", new InjectionProperty("Name", "I am Circle"));

    // with rectangle name
    container.RegisterType<IShape, Rectangle>("Rectangle", new InjectionConstructor("I am Rectangle"));

    // Complex type like Constructor, Property and method injection
    container.RegisterType<DIV2Controller, DIV2Controller>(
        new InjectionConstructor("Constructor Value1", container.Resolve<IShape>("Circle"), "Constructor Value2", container.Resolve<IShape>()),
        new InjectionMethod("Initialize"),
        new InjectionMethod("Initialize2", "Value1", container.Resolve<IShape>("Circle"), "Value2", container.Resolve<IShape>()),
        new InjectionProperty("MyPropertyName", "Property Value"),
        new InjectionProperty("PiValue1", container.Resolve<double>("PiValueExample1")),
        new InjectionProperty("Shape", container.Resolve<IShape>("Rectangle")),
        new InjectionProperty("PiValue2", container.Resolve<double>("PiValueExample2")));
}
Respondeu 30/06/2018 em 19:27
fonte usuário

Respondeu 07/12/2019 em 09:45
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more