[dependency-injection] DI 코드와 달리 IoC 컨테이너가 필요한 이유는 무엇입니까? [닫은]

와, Joel이 이것을 선호한다고 믿을 수 없습니다.

var svc = new ShippingService(new ProductLocator(),
   new PricingService(), new InventoryService(),
   new TrackingRepository(new ConfigProvider()),
   new Logger(new EmailLogger(new ConfigProvider())));

이 위에 :

var svc = IoC.Resolve<IShippingService>();

많은 사람들은 의존성 체인이 중첩 될 수 있다는 것을 인식하지 못하고 수동으로 연결하는 것이 까다로워집니다. 공장에서도 코드 복제는 그만한 가치가 없습니다.

IoC 컨테이너는 복잡 할 수 있습니다. 그러나이 간단한 경우에는 매우 쉽다는 것을 보여주었습니다.

자, 이것을 더 정당화합시다. 스마트 UI에 바인딩하려는 일부 엔터티 또는 모델 개체가 있다고 가정 해 봅시다. 이 스마트 UI (Shindows Morms라고 함)는 INotifyPropertyChanged를 구현하여 변경 내용 추적 및 UI를 적절히 업데이트 할 수 있기를 원합니다.

“좋아, 그렇게 힘들지 않아”라고 쓰기 시작합니다.

이것으로 시작하십시오 :

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime CustomerSince { get; set; }
    public string Status { get; set; }
}

.. 그리고 함께 끝 이 :

public class UglyCustomer : INotifyPropertyChanged
{
    private string _firstName;
    public string FirstName
    {
        get { return _firstName; }
        set
        {
            string oldValue = _firstName;
            _firstName = value;
            if(oldValue != value)
                OnPropertyChanged("FirstName");
        }
    }

    private string _lastName;
    public string LastName
    {
        get { return _lastName; }
        set
        {
            string oldValue = _lastName;
            _lastName = value;
            if(oldValue != value)
                OnPropertyChanged("LastName");
        }
    }

    private DateTime _customerSince;
    public DateTime CustomerSince
    {
        get { return _customerSince; }
        set
        {
            DateTime oldValue = _customerSince;
            _customerSince = value;
            if(oldValue != value)
                OnPropertyChanged("CustomerSince");
        }
    }

    private string _status;
    public string Status
    {
        get { return _status; }
        set
        {
            string oldValue = _status;
            _status = value;
            if(oldValue != value)
                OnPropertyChanged("Status");
        }
    }

    protected virtual void OnPropertyChanged(string property)
    {
        var propertyChanged = PropertyChanged;

        if(propertyChanged != null)
            propertyChanged(this, new PropertyChangedEventArgs(property));
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

그것은 역겨운 배관 코드이며, 손으로 직접 코드를 작성 하면 클라이언트에서 훔치는 것 입니다. 더 좋고 똑똑한 작업 방법이 있습니다.

그 용어를 듣고 더 똑똑하지 않고 더 똑똑하게 일하십니까?

팀의 똑똑한 사람이 와서 다음과 같이 말했습니다. “더 쉬운 방법이 있습니다”

속성을 가상으로 만들면 (진정, 그다지 큰 문제는 아님) 해당 속성 동작을 자동으로 직조 할 수 있습니다 . (이를 AOP라고하지만 이름에 대해 걱정하지 말고 그것이 당신을 위해 무엇을 할 것인지에 집중하십시오)

사용중인 IoC 도구에 따라 다음과 같은 작업을 수행 할 수 있습니다.

var bindingFriendlyInstance = IoC.Resolve<Customer>(new NotifyPropertyChangedWrapper());

of! 해당 개체의 모든 가상 속성 설정 기에서 모든 수동 INotifyPropertyChanged BS가 자동으로 생성됩니다.

이거 마법이야? 예 ! 이 코드가 작동한다는 사실을 신뢰할 수 있으면 mumbo-jumbo를 감싸는 해당 속성을 모두 건너 뛸 수 있습니다. 해결해야 할 비즈니스 문제가 있습니다.

AOP를 수행하기위한 IoC 도구의 다른 흥미로운 용도 :

• 선언 및 중첩 데이터베이스 트랜잭션
• 선언적이고 중첩 된 작업 단위
• 벌채 반출
• 사전 / 사후 조건 (계약에 의한 설계)

답변

public class CustomerPresenter
{
  public CustomerPresenter() : this(new CustomerView(), new CustomerService())
  {}

  public CustomerPresenter(ICustomerView view, ICustomerService service)
  {
    // init view/service fields
  }
  // readonly view/service fields
}

public class CustomerPresenter
{
  public CustomerPresenter() : this(IoC.Resolve<ICustomerView>(), IoC.Resolve<ICustomerService>())
  {}

  public CustomerPresenter(ICustomerView view, ICustomerService service)
  {
    // init view/service fields
  }
  // readonly view/service fields
}

public static IoC
{
   private static readonly IUnityContainer _container;
   static IoC()
   {
     InitializeIoC();
   }

   static void InitializeIoC()
   {
      _container = new UnityContainer();
      _container.RegisterType<ICustomerView, CustomerView>();
      _container.RegisterType<ICustomerService, CustomerService>();
      // all other RegisterTypes and RegisterInstances can go here in one file.
      // one place to change dependencies is good.
   }
}

public void GetPresenter()
{
    var presenter = new CustomerPresenter(new CustomerService(new CustomerRepository(new DB())));
}

class CustomerPresenter
{
    private readonly ICustomerService service;
    public CustomerPresenter(ICustomerService service)
    {
        this.service = service;
    }
}

class CustomerService
{
    private readonly IRespository<Customer> repository;
    public CustomerService(IRespository<Customer> repository)
    {
        this.repository = repository;
    }
}

class CustomerRepository : IRespository<Customer>
{
    private readonly DB db;
    public CustomerRepository(DB db)
    {
        this.db = db;
    }
}

class DB { }

public static IoC
{
   private IUnityContainer _container;
   static IoC()
   {
       InitializeIoC();
   }

   static void InitializeIoC()
   {
      _container = new UnityContainer();
      _container.RegisterType<ICustomerService, CustomerService>();
      _container.RegisterType<IRepository<Customer>, CustomerRepository>();
   }

   static T Resolve<T>()
   {
      return _container.Resolve<T>();
   }
}

public void GetPresenter()
{
   var presenter = IoC.Resolve<CustomerPresenter>();
   // presenter is loaded and all of its nested child dependencies 
   // are automatically injected
   // -
   // Also, note that only the Interfaces need to be registered
   // the concrete types like DB and CustomerPresenter will automatically 
   // resolve.
}