누군가 Microsoft Unity를 설명 할 수 있습니까?

MSDN에 대한 Unity (Dependency Injection, Inversion of Control)에 대한 기사를 읽었지만 간단한 용어 (또는 간단한 예)로 설명해야한다고 생각합니다. MVPC 패턴에 익숙하지만 (여기서는 여기에서 사용)이 Unity를 아직 파악할 수 없으며 애플리케이션 디자인의 다음 단계라고 생각합니다.

Unity는 IoC "컨테이너"입니다. Google StructureMap을 대신 사용해보십시오. IoC가 처음 생겼을 때 생각하기가 조금 더 쉽습니다.

기본적으로 IoC를 이해하면 수행중인 작업이 객체 생성 시점을 제어하는 ​​것임을 이해합니다.

IoC없이 :

public class MyClass
{
   IMyService _myService; 

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

IoC 컨테이너 :

public class MyClass
{
   IMyService _myService; 

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

IoC가 없으면 IMyService를 사용하는 클래스에서 사용할 구체적인 서비스 버전을 새로 만들어야합니다. 그리고 그것은 여러 가지 이유로 나쁩니다 (클래스를 특정 콘크리트 버전의 IMyService에 결합 했으므로 쉽게 테스트 할 수 없으며 쉽게 변경할 수 없습니다.)

IoC 컨테이너를 사용하면 컨테이너를 "구성"하여 이러한 종속성을 해결합니다. 따라서 생성자 기반 주입 방식을 사용하면 IMyService 종속성에 대한 인터페이스를 생성자에 전달하면됩니다. 컨테이너로 MyClass를 만들면 컨테이너가 IMyService 종속성을 해결합니다.

StructureMap을 사용하여 컨테이너를 구성하는 방법은 다음과 같습니다.

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

그래서 당신이 한 일은 컨테이너에 "누군가가 IMyService를 요청할 때 SomeConcreteService의 사본을 제공하십시오."라고 말합니다. 또한 누군가 MyClass를 요청할 때 구체적인 MyClass를 얻도록 지정했습니다.

이것이 IoC 컨테이너가 실제로하는 전부입니다. 그들은 더 많은 일을 할 수 있지만, 그것은 추력입니다-그들은 당신을 위해 의존성을 해결하므로, 필요하지 않습니다 (그리고 코드 전체에서 "새"키워드를 사용할 필요가 없습니다).

마지막 단계 : MyClass를 만들 때 다음을 수행하십시오.

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

희망이 도움이됩니다. 저에게 이메일을 보내 주시기 바랍니다.

방금 David Hayden의 30 분 Unity Dependency Injection IoC Screencast를 보았고 그 예가 좋은 설명이라고 생각했습니다. 다음은 쇼 노트의 스 니펫입니다.

스크린 캐스트는 Unity IoC의 몇 가지 일반적인 사용법을 보여줍니다.

• 컨테이너에없는 유형 만들기
• 타입 맵핑 등록 및 해결
• 명명 된 형식 매핑 등록 및 해결
• 싱글 톤, LifetimeManager 및 ContainerControlledLifetimeManager
• 기존 인스턴스 등록
• 기존 인스턴스에 종속성 주입
• App.config / Web.config를 통해 UnityContainer 채우기
• 종속성 속성이 아닌 주입 API를 통해 종속성 지정
• 중첩 (부모-자식) 컨테이너 사용

Unity는 다른 많은 라이브러리와 마찬가지로 라이브러리를 직접 만들지 않고도 요청 된 유형의 인스턴스를 얻을 수 있습니다. 그래서 주어진.

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

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

Unity와 같은 라이브러리를 사용하여 ICalculator 유형 (일명 IoC (Inversion of Control))이 요청 될 때 계산기가 반환되도록 계산기를 등록 할 수 있습니다 (이 예제는 이론적으로는 정확하지 않습니다).

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

이제 ICalculator의 인스턴스를 원할 때 ...

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

IoC 라이브러리는 일반적으로 유형을 확인할 때마다 싱글 톤을 유지하거나 새 인스턴스를 작성하도록 구성 할 수 있습니다.

이제 ICalculator에 의존하는 클래스가 있다고 가정 해 봅시다.

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

    private ICalculator _calc;
}

그리고 생성자가 생성 될 때 생성자에 객체를 주입하도록 라이브러리를 설정할 수 있습니다.

따라서 DI 또는 Dependency Injection은 다른 개체에 필요할 수있는 개체를 주입하는 것을 의미합니다.

이 사람 WilcoxTutorials는 초보자를 겨냥한 Unity 컨테이너의 훌륭한 데모를 제공합니다.

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

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

30 분 안에 당신은 기본을 이해할 것입니다!

Unity는 IoC입니다. IoC의 요점은 유형 자체 외부의 유형 간 종속성 배선을 추상화하는 것입니다. 이것은 몇 가지 장점이 있습니다. 우선, 그것은 중앙에서 수행되므로 종속성이 변경 될 때 많은 단위를 변경할 필요가 없습니다 (단위 테스트의 경우 일 수 있음).

또한 코드 대신 구성 데이터를 사용하여 배선을 수행하는 경우 실제로 배포 후 종속성을 다시 배선하여 코드를 변경하지 않고도 응용 프로그램의 동작을 변경할 수 있습니다.

MSDN에는 Unity 를 사용한 종속성 주입에 대한 개발자 안내서 가 있으며 유용 할 수 있습니다.

Developer 's Guide는 의존성 주입의 기본 사항으로 시작하며 의존성 주입에 Unity를 사용하는 방법에 대한 예제를 계속합니다. 2014 년 2 월 현재 개발자 안내서는 2013 년 4 월에 릴리스 된 Unity 3.0에 대해 설명합니다.

ASP.NET Web API 2의 Dependency Injection 예제를 대부분 다루고 있습니다.

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

DIAutoV2Controller.cs에서는 자동 주입 메커니즘이 사용됩니다.

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

DIV2Controller.cs에서 모든 것은 Dependency Configuration 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;
    }
}

종속성 해결 프로그램 구성

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