Может кто-нибудь объяснить Microsoft Unity?

Я читал статьи о MSDN о Unity (Injection Dependency, Inversion of Control), но я думаю, что мне это нужно объяснять простыми словами (или простыми примерами). Я знаком с шаблоном MVPC (мы его здесь используем), но я пока не могу понять эту вещь Unity, и я думаю, что это следующий шаг в разработке нашего приложения.

4b9b3361

Единство - это просто контейнер "IoC". Google StructureMap и попробуйте вместо этого. Похоже, что немного легче, чем когда-либо, но я не знаю.

В принципе, если вы понимаете 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, вы не можете unit test легко, вы не можете легко его изменить и т.д.)

С контейнером 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>();

Надеюсь, что это поможет. Не стесняйтесь, напишите мне.

136
ответ дан 04 марта '09 в 2:02
источник

Я просто смотрел 30-минутную инъекцию IoC Screencast от Unity Dependency от David Hayden и считал, что это было хорошее объяснение примерами. Вот фрагмент из заметок:

Скринкаст показывает несколько общих применений Unity IoC, например:

  • Создание типов в контейнере
  • Регистрация и разрешение типов.
  • Регистрация и разрешение именных типов.
  • Синглеты, Менеджеры времени жизни и ContainerControlledLifetimeManager
  • Регистрация существующих экземпляров
  • Включение зависимостей в существующие экземпляры
  • Заполнение UnityContainer через App.config/Web.config
  • Задание зависимостей через API инжекции в отличие от атрибутов зависимостей
  • Использование вложенных (родительских) контейнеров
35
ответ дан 26 мая '09 в 3:52
источник

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 типа aka 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 означает инъекцию любого объекта, который может потребоваться другому.

27
ответ дан 04 марта '09 в 2:05
источник

Единство - это IoC. Точка IoC - это абстрагирование проводки зависимостей между типами вне самих типов. Это имеет несколько преимуществ. Прежде всего, это делается централизованно, что означает, что вам не нужно менять много кода при изменении зависимостей (что может иметь место для модульных тестов).

Кроме того, если проводка выполняется с использованием данных конфигурации вместо кода, вы действительно можете переустанавливать зависимости после развертывания и, таким образом, изменять поведение приложения без изменения кода.

8
ответ дан 04 марта '09 в 3:33
источник

MSDN имеет Руководство разработчика по внедрению зависимостей с использованием Unity, которое может быть полезно.

Руководство разработчика начинается с основ того, что такое инъекция зависимостей, и продолжает примеры использования Unity для инъекций зависимостей. По состоянию на февраль 2014 года Руководство разработчика охватывает Unity 3.0, выпущенный в апреле 2013 года.

4
ответ дан 11 февр. '14 в 23:24
источник