Dependency Injection (DI) является одной из ключевых парадигм проектирования, которая значительно упрощает управление зависимостями в приложениях. Она особенно полезна для разработки модульных и тестируемых приложений, так как позволяет инвертировать контроль над созданием объектов. В этой статье мы рассмотрим, как можно самостоятельно реализовать механизм DI в C#, чтобы лучше понять его основы и принципы работы.
-
Управление зависимостями: Для приложений, состоящих из нескольких компонентов или классов, управление этими зависимостями может стать сложной задачей. DI позволяет централизованно контролировать создание объектов и внедрение их зависимостей.
-
Тестируемость: С помощью DI можно легко заменять реализации классов на моки или фейки для тестирования, не изменяя код самого приложения.
-
Гибкость и масштабируемость: Позволяет изменять и расширять функциональность без значительных переписываний существующего кода.
-
Разделение ответственности: DI способствует разграничению обязанностей между классами, улучшая модульность приложения.
-
Контейнер: Это централизованный объект, который отвечает за создание экземпляров и внедрение зависимостей. Контейнер хранит информацию о том, какие классы используются в приложении и как их нужно инжектировать.
-
Регистрация: Включает определение, какие типы объектов должны быть созданы и каким образом будет осуществляться их резолвинг.
-
Внедрение зависимостей (Injection): Процесс, при котором необходимые зависимости передаются в экземпляры классов.
Чтобы создать собственный DI-механизм, мы будем разрабатывать простой контейнер. Это позволит не только изучить принципы работы DI, но и увидеть его реализацию на практике.
Первый шаг — определение базовых интерфейсов для контейнера. Мы создадим два основных интерфейся:
public interface IDependencyResolver
{
T Resolve<T>();
}
public interface IServiceProvider
{
object GetService(Type serviceType);
}
Теперь мы создадим класс Container, который будет реализовывать эти интерфейсы:
public class Container : IDependencyResolver, IServiceProvider
{
private readonly Dictionary<Type, Func<object>> _registrations = new();
public void Register<TService>(Func<TService> implementationFactory)
{
_registrations[typeof(TService)] = () => implementationFactory();
}
public T Resolve<T>()
{
return (T)GetService(typeof(T));
}
public object GetService(Type serviceType)
{
if (_registrations.TryGetValue(serviceType, out var factory))
{
return factory();
}
throw new InvalidOperationException($"No registration for {serviceType}");
}
}
Теперь мы можем регистрировать зависимости и создавать экземпляры классов через наш контейнер:
var container = new Container();
// Регистрация сервиса
container.Register<IMyService>(() => new MyServiceImpl());
// Использование ресолвера для получения сервиса
IMyService myService = container.Resolve<IMyService>();
Для демонстрации работы контейнера создадим простой интерфейс и его реализацию:
public interface IMyService
{
void PerformAction();
}
public class MyServiceImpl : IMyService
{
public void PerformAction()
{
Console.WriteLine("Action Performed");
}
}
Мы можем расширить наш контейнер для поддержки различных жизненных циклов объектов, таких как Singleton или Transient. Для этого добавим флаги при регистрации:
public enum Lifecycle
{
Singleton,
Transient
}
public class Container : IDependencyResolver, IServiceProvider
{
private readonly Dictionary<Type, (Func<object>, object)> _singletonRegistrations = new();
private readonly Dictionary<Type, Func<object>> _transientRegistrations = new();
public void Register<TService>(Func<TService> implementationFactory, Lifecycle lifecycle = Lifecycle.Transient)
{
if (lifecycle == Lifecycle.Singleton)
{
if (_singletonRegistrations.ContainsKey(typeof(TService)))
throw new InvalidOperationException($"Singleton already registered: {typeof(TService)}");
_singletonRegistrations[typeof(TService)] = (implementationFactory, null);
}
else
{
_transientRegistrations[typeof(TService)] = () => implementationFactory();
}
}
public T Resolve<T>()
{
return (T)GetService(typeof(T));
}
public object GetService(Type serviceType)
{
if (_singletonRegistrations.TryGetValue(serviceType, out var singleton))
{
if (singleton.Item2 == null)
{
singleton.Item2 = singleton.Item1();
}
return singleton.Item2;
}
if (_transientRegistrations.TryGetValue(serviceType, out var factory))
{
return factory();
}
throw new InvalidOperationException($"No registration for {serviceType}");
}
}
После реализации основной логики, важно протестировать наш контейнер. Создадим несколько тестов для проверки корректности регистрации и создания экземпляров:
[TestClass]
public class ContainerTests
{
[TestMethod]
public void Resolve_Should_Return_Correct_Instance()
{
var container = new Container();
// Регистрируем сервис как transient
container.Register<IMyService>(() => new MyServiceImpl(), Lifecycle.Transient);
IMyService service1 = container.Resolve<IMyService>();
IMyService service2 = container.Resolve<IMyService>();
Assert.IsNotNull(service1);
Assert.IsNotNull(service2);
// Проверяем, что создаются разные экземпляры
Assert.AreNotEqual(service1, service2);
}
[TestMethod]
public void ResolveSingleton_Should_Return_Same_Instance()
{
var container = new Container();
// Регистрируем сервис как singleton
container.Register<IMyService>(() => new MyServiceImpl(), Lifecycle.Singleton);
IMyService service1 = container.Resolve<IMyService>();
IMyService service2 = container.Resolve<IMyService>();
Assert.IsNotNull(service1);
Assert.IsNotNull(service2);
// Проверяем, что создаются один и тот же экземпляр
Assert.AreEqual(service1, service2);
}
}
Реализация собственного механизма DI в C# помогает глубже понять принципы работы инверсии контроля и управления зависимостями. Подобная реализация может служить отличным образовательным проектом для изучения архитектуры приложений, а также может быть основой для создания более сложных и мощных контейнеров DI. Существуют многочисленные готовые решения, такие как Autofac или Microsoft.Extensions.DependencyInjection, но знание того, как они работают изнутри, может значительно улучшить понимание их преимуществ и ограничений.

