Копировать конфигурацию сборки из другого проекта в Visual Studio

Попробуем простой пример с классами автомобилей и двигателей, любой автомобиль нуждается в двигателе, чтобы идти куда угодно, по крайней мере на данный момент. Итак, ниже, как код будет выглядеть без инъекции зависимостей.

public class Car
{
    public Car()
    {
        GasEngine engine = new GasEngine();
        engine.Start();
    }
}

public class GasEngine
{
    public void Start()
    {
        Console.WriteLine("I use gas as my fuel!");
    }
}

И чтобы создать экземпляр класса Car, мы будем использовать следующий код:

Car car = new Car();

Проблема с этим кодом, который мы плотно в сочетании с GasEngine, и если мы решим изменить его на ElectricityEngine, тогда нам нужно будет переписать класс Car. И чем больше приложение, тем больше проблем и головной боли нам придется добавлять и использовать новый тип движка.

Другими словами, при таком подходе наш класс высокого класса Car зависит от класса GasEngine более низкого уровня, который нарушает принцип инверсии зависимостей (DIP) от SOLID. DIP предполагает, что мы должны зависеть от абстракций, а не от конкретных классов. Итак, чтобы удовлетворить это, мы вводим интерфейс IEngine и переписываем код, как показано ниже:

    public interface IEngine
    {
        void Start();
    }

    public class GasEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I use gas as my fuel!");
        }
    }

    public class ElectricityEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I am electrocar");
        }
    }

    public class Car
    {
        private readonly IEngine _engine;
        public Car(IEngine engine)
        {
            _engine = engine;
        }

        public void Run()
        {
            _engine.Start();
        }
    }

Теперь наш класс Car зависит только от интерфейса IEngine, а не от конкретной реализации движка. Теперь единственным трюком является то, как мы создаем экземпляр автомобиля и даем ему настоящий конкретный класс двигателя, такой как GasEngine или ElectricityEngine. Вот здесь и начинается Injection Dependency.

   Car gasCar = new Car(new GasEngine());
   gasCar.Run();
   Car electroCar = new Car(new ElectricityEngine());
   electroCar.Run();

Здесь мы в основном вводим (передаем) нашу зависимость (экземпляр Engine) конструктору Car. Итак, теперь у наших классов есть свободная связь между объектами и их зависимостями, и мы можем легко добавлять новые типы двигателей, не меняя класс Car.

Основное преимущество Injection Dependency заключается в том, что классы более слабо связаны, потому что они не имеют жестко закодированных зависимостей. Это следует принципу инверсии зависимостей, о котором говорилось выше. Вместо ссылок на конкретные реализации классы запрашивают абстракции (обычно интерфейсы), которые предоставляются им при построении класса.

Итак, в конце Инъекция зависимостей - это всего лишь метод достижения свободной связи между объектами и их зависимости. Вместо того, чтобы напрямую создавать зависимости, необходимые классу для выполнения своих действий, зависимости предоставляются классу (чаще всего) с помощью инъекции конструктора.

Также, когда у нас много зависимостей, это очень хорошо практикуйте использование контейнеров Inversion of Control (IoC), которые мы можем определить, какие интерфейсы должны быть сопоставлены с конкретными реализациями для всех наших зависимостей, и мы можем разрешить эти зависимости для нас, когда он конструирует наш объект. Например, мы можем указать в отображении для контейнера IoC, что зависимость IEngine должна быть сопоставлена ​​с классом GasEngine, и когда мы спросим контейнер IoC для экземпляра нашего класса Car, он автоматически построит наш класс Car с зависимостью GasEngine .

UPDATE: Недавно просмотрел курс о EF Core от Джули Лерман и также понравилось ее краткое определение о DI.

Инъекция зависимостей - это шаблон, позволяющий вашему приложению вводить объекты «на лету» в классы, которые им нужны, не заставляя эти классы отвечать за эти объекты. Это позволяет вашему коду быть более слабо связанными, и Entity Framework Core подключается к этой же системе сервисов.