Dependency Injection в C#: простое руководство для начинающих

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Что такое Dependency Injection (DI) в C# и зачем это нужно?

Dependency Injection (внедрение зависимостей) — это паттерн проектирования, который позволяет сделать код более гибким, тестируемым и поддерживаемым. Вместо того чтобы класс сам создавал объекты, от которых он зависит, эти объекты "внедряются" извне. Это один из ключевых принципов, лежащих в основе современной разработки на C# и .NET.

Представьте, что вы пишете приложение для отправки email-уведомлений. Если ваш класс NotificationService будет напрямую создавать экземпляр SmtpClient, то при смене почтового сервера или необходимости использовать другой способ отправки (например, через API), вам придется переписывать код. DI решает эту проблему.

Проблема без Dependency Injection

Рассмотрим типичный пример плохого кода, где зависимость создается внутри класса:

public class EmailService
{
    private SmtpClient _smtpClient;

    public EmailService()
    {
        // Жесткая привязка к конкретной реализации
        _smtpClient = new SmtpClient("smtp.gmail.com", 587);
    }

    public void SendEmail(string to, string subject, string body)
    {
        // Логика отправки
    }
}

public class NotificationService
{
    private EmailService _emailService;

    public NotificationService()
    {
        _emailService = new EmailService(); // Жесткая связь
    }

    public void NotifyUser(string email)
    {
        _emailService.SendEmail(email, "Уведомление", "Привет!");
    }
}

Недостатки такого подхода:

Высокая связанность (tight coupling): Классы NotificationService и EmailService жестко привязаны друг к другу.
Сложность тестирования: Невозможно подменить EmailService на mock-объект при юнит-тестировании.
Сложность расширения: Если нужно добавить SMS-уведомления, придется менять логику внутри NotificationService.

Реализация Dependency Injection в C#

DI решает эти проблемы, используя три основных подхода: внедрение через конструктор, через свойство и через метод. Самый распространенный и рекомендуемый — внедрение через конструктор (Constructor Injection).

Шаг 1. Создаем интерфейс

Сначала определим абстракцию (интерфейс), которая описывает контракт для отправки сообщений:

public interface IMessageSender
{
    void Send(string to, string message);
}

Шаг 2. Реализуем конкретные сервисы

Теперь создадим несколько реализаций этого интерфейса:

public class EmailSender : IMessageSender
{
    public void Send(string to, string message)
    {
        Console.WriteLine($"Отправка email на {to}: {message}");
    }
}

public class SmsSender : IMessageSender
{
    public void Send(string to, string message)
    {
        Console.WriteLine($"Отправка SMS на {to}: {message}");
    }
}

Шаг 3. Применяем DI через конструктор

Теперь класс NotificationService не создает зависимости сам, а получает их через конструктор:

public class NotificationService
{
    private readonly IMessageSender _messageSender;

    // Внедрение зависимости через конструктор
    public NotificationService(IMessageSender messageSender)
    {
        _messageSender = messageSender;
    }

    public void Notify(string userContact, string message)
    {
        _messageSender.Send(userContact, message);
    }
}

Теперь мы можем легко подменять реализации:

// Используем Email
var emailSender = new EmailSender();
var emailNotifier = new NotificationService(emailSender);
emailNotifier.Notify("user@example.com", "Привет через email!");

// Используем SMS
var smsSender = new SmsSender();
var smsNotifier = new NotificationService(smsSender);
smsNotifier.Notify("+79123456789", "Привет через SMS!");

DI-контейнеры (IoC контейнеры) в .NET

В реальных проектах ручное создание всех зависимостей становится утомительным. На помощь приходят IoC-контейнеры (Inversion of Control). В .NET Core и .NET 5+ встроенный контейнер для DI уже есть — он находится в пространстве имен Microsoft.Extensions.DependencyInjection.

Пример использования встроенного DI-контейнера

Сначала установим зависимости (если это консольное приложение):

dotnet add package Microsoft.Extensions.DependencyInjection

Теперь настроим контейнер и зарегистрируем наши сервисы:

using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main(string[] args)
    {
        // 1. Создаем коллекцию сервисов
        var services = new ServiceCollection();

        // 2. Регистрируем сервисы
        services.AddTransient<IMessageSender, EmailSender>();
        services.AddTransient<NotificationService>();

        // 3. Строим провайдер сервисов
        var serviceProvider = services.BuildServiceProvider();

        // 4. Получаем экземпляр NotificationService с уже внедренными зависимостями
        var notifier = serviceProvider.GetService<NotificationService>();
        notifier.Notify("user@example.com", "Привет от DI-контейнера!");
    }
}

Важно: В ASP.NET Core DI-контейнер настраивается автоматически в файле Program.cs или Startup.cs. Вам нужно только зарегистрировать свои сервисы в методе ConfigureServices.

Времена жизни сервисов (Service Lifetimes)

При регистрации в контейнере важно выбрать правильное время жизни:

Transient — новый экземпляр создается при каждом запросе (подходит для легковесных сервисов).
Scoped — один экземпляр на один HTTP-запрос (используется в веб-приложениях).
Singleton — один экземпляр на всё время работы приложения (для сервисов, хранящих состояние).