제어의 역전을 통한 의존성 주입

이번 포스트는 어쩌다 보니 바로 앞 글의 후속편이 되었습니다. 이번에는 의존성 주입(dependency injection)과 밀접한 관련이 있는 제어의 역전에 대해 정리해 봅니다. 그리고 매우 단순화된 버전의 IoC 컨테이너를 만들어 보면서 어떻게 제어의 역전을 이용해서 의존성을 주입할 수 있는지 알아봅니다.

제어의 역전(제어의 반전, Inversion of Control; IoC)‌이란 프로그래머가 직접 프로그램의 흐름을 제어하는 코드를 작성하지 않고, 그 대신 외부 프레임워크의 흐름 제어를 받도록 하는 소프트웨어 개발 원칙입니다. IoC를 따라 소프트웨어를 개발하면 인스턴스의 생성이나 이벤트 처리기 등의 호출을 프레임워크가 알아서 해 줍니다. 한 마디로 프로그램 흐름의 큰 틀은 프레임워크 안쪽에 정의되어 있고, 우리는 그저 사이사이에 나 있는 빈 칸을 채우기만 하면 되는 것‌이죠. 그리고 그 빈 칸을 채울 때는 프레임워크에서 요구하는 인터페이스를 구현하기만 하면 되기 때문에 더욱 더 유연하고 모듈화된 소프트웨어를 만들 수 있습니다.

IoC 컨테이너

제어의 역전을 활용하면 이전 포스트에서 설명한 의존성 주입을 간편하게 할 수 있습니다. 개체 간의 의존성 정보를 등록하고 어떤 클래스의 인스턴스 또는 어떤 인터페이스를 구현하는 인스턴스를 요청하면 알아서 의존성이 해결된(resolved) 인스턴스를 만들어 주는 것을 IoC 컨테이너‌라고 하는데, MVVM Light Toolkit이나 Prism같은 주요 라이브러리에서는 이미 기능이 풍부한 IoC 컨테이너를 제공하고 있습니다.

IoC 컨테이너는 기본적으로 아래와 같은 기능을 제공합니다.

• void Register<TInterface, TConcrete>()

  TInterface 인터페이스와 이를 구현하는 TConcrete 클래스 간의 매핑을 등록합니다. 이후에 TInterface에 의존하는 인스턴스가 요청될 경우, TConcrete 타입의 개체를 인스턴스에 주입하게 됩니다.

• void Register<TClass>()

  클래스 TClass의 의존성을 해결할 수 있도록 타입 TClass를 등록합니다.

• T GetInstance<T>()

  의존성이 해결된 T 타입의 인스턴스를 가져옵니다. T가 클래스의 타입인 경우에는 그 클래스의 인스턴스가, T가 인터페이스의 타입인 경우에는 그 인터페이스를 구현하는 클래스의 인스턴스가 반환됩니다.

실제로 사용되는 IoC 컨테이너는 key를 사용하여 동일한 클래스나 인터페이스에 대한 인스턴스를 여러 개 등록할 수도 있고, 추가적인 매개변수를 받아 기본 생성자가 아닌 특정 오버로드된 생성자를 호출하여 인스턴스를 생성할 수도 있습니다. 하지만 이러한 부가 기능들은 이번 포스트에서는 다루지 않겠습니다.

이전 포스트에서 다룬 메시지 박스 시나리오를 여기에 적용해 봅시다. 아래 코드는 전역에서 사용 가능한 IoC 컨테이너 ioc가 있다고 가정했을 때, 응용 프로그램의 Startup 이벤트 핸들러에서 의존성을 등록하고 자동으로 의존성이 주입된 ViewModel의 인스턴스를 가져오는 동작을 기술합니다.

private void App_Startup(object sender, StartupEventArgs e)
{
  if (IsTesting)
    ioc.Register<IMessageBoxProvider, NullMessageBoxProvider>();
  else
    ioc.Register<IMessageBoxProvider, WpfMessageBoxProvider>();

  ioc.Register<ViewModel>();

  ViewModel vm = ioc.GetInstance<ViewModel>();

  // ...
}

만들어 볼까…?

IoC 컨테이너는 제대로 써먹을 생각으로 만든다면 꽤 복잡합니다. 그리고 서드 파티 라이브러리에 구현되어 있는 IoC 컨테이너가 훨씬 더 강력하고 안전하고 효율적일 지도 모릅니다. 하지만 개인 프로젝트를 하면서 외부 프레임워크를 사용하길 원치 않는 경우나 개인적인 호기심 또는 학습을 위해서 한 번 쯤 구현해 보는 것은 나쁘지 않다고 생각합니다.

아래 그림과 같은 의존 관계가 있을 때, 간단한 IoC 컨테이너를 만들어서 의존성이 해결된 X의 인스턴스를 가져올 수 있도록 해 봅시다.

1. 타입 등록

IoC 컨테이너를 사용하기 위해 가장 먼저 하는 작업은 컨테이너에 타입을 등록하는 것입니다. 우선 인터페이스 타입을 구체적인 클래스의 타입에 대응시키는 것은 연관 자료구조를 사용하면 간단하게 구현할 수 있을 것 같습니다.

private readonly Dictionary<Type, Type> _typeMap;

구체적인 클래스와 Register<T>()를 통해 등록된 클래스는 다른 인터페이스에 대한 의존성을 가지고 있을 수 있습니다. 이러한 타입들은 의존성 해결의 대상이 되며, 이러한 타입들을 저장하는 컬렉션도 만들어 놔야 합니다.

private readonly HashSet<Type> _targets;

이 두 컬렉션을 사용해서 Register<Ti, Tc>()와 Register<Tc>() 메서드를 구현할 수 있습니다.

public void Register<TInterface, TConcrete>()
  where TInterface : class
  where TConcrete : class, TInterface, new()
{
  _typeMap.Add(typeof(TInterface), typeof(TConcrete));
  _targets.Add(typeof(TConcrete));
}

public void Register<TClass>() where TClass : class, new()
{
  _targets.Add(typeof(TClass));
}

위의 두 메서드를 사용해서 타입을 등록하고 나면 IoC 컨테이너의 상태는 아래의 그림과 같을 것입니다.

ioc.Register<IA, A>();
ioc.Register<IB, B>();
ioc.Register<IC, C>();
ioc.Register<X>();

2. 의존성 탐색

어떤 타입이 어떤 인터페이스에 의존하는 지는 어떻게 알 수 있을까요? 사실 이러한 기준은 각자 정하기 나름이라고 생각합니다. 여기서 저는 클래스 A에 액세스 제한 범위와는 관계 없이 인터페이스 IX 타입의 속성이 정의되어 있는 경우, “A가 IX에 의존한다”고 하겠습니다. C#에서는 리플렉션을 사용하면 실행 시간에 타입 정보를 조회하여 어떤 속성이 있는지 확인할 수 있습니다.

private IEnumerable<PropertyInfo> GetDependencies(Type type)
  => type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
         .Where(propInfo => propInfo.PropertyType.IsInterface)
         .Where(propInfo => _typeMap.ContainsKey(propInfo.PropertyType))

위 메서드는 type이 나타내는 타입에 정의된 속성들 중에서 속성의 타입이 현재 IoC 컨테이너에 등록된 인터페이스의 타입인 것들만 찾아서 반환하는 메서드입니다.

3. 타입 인식

이제 GetInstance<T>() 메서드만 구현하면 이를 통해 의존성이 해결된 인스턴스를 받아서 사용할 수 있게 됩니다. 이 메서드의 구현에 앞서서, 타입 매개 변수 T에 어떤 타입이 대입되는지에 따라 실제로 어떤 타입의 인스턴스를 가져와야 하는지 알아봅시다.

• T가 Register<Ti, Tc>()를 통해 등록된 인터페이스 타입일 때: _typeMap을 조회하여 Tc 타입의 인스턴스를 반환해야 합니다.

• T가 Register<Tc>()를 통해 등록된 클래스 타입일 때: 바로 Tc 타입의 인스턴스를 반환하면 됩니다.

• T가 Register<Tc>()를 통해 등록된 클래스 타입에서 파생된 타입일 때: T도 Tc와 동일한 의존 관계를 포함하고 있으므로 T의 인스턴스를 생성하되, Tc와 동일한 기준에 따라 의존성을 해결해야 합니다.

• 그 외의 경우: T는 IoC 컨테이너에 등록된 타입이 아니기 때문에 의존성을 해결할 수 없습니다. (예외 발생)

위 정보를 바탕으로, 어떤 타입이 주어졌을 때 IoC 컨테이너에 알려진 타입 중 하나를 반환하는 메서드인 ResolveType 메서드를 만들어 봅시다. 타입을 등록하는 제네릭 메서드의 타입 매개 변수에 대한 제약 사항에 의해, 이 ResolveType 메서드가 반환하는 타입은 모두 매개변수가 없는 생성자를 이용해 인스턴스를 생성할 수 있는 클래스의 타입입니다.

private Type ResolveType(Type type)
{
  if (_typeMap.TryGetValue(type, out Type cType)
    return cType;

  Type baseType = type;

  while (!_targets.Contains(baseType))
  {
    baseType = baseType.BaseType;

    if (baseType == null)
      throw new InvalidOperationException("등록되지 않은 타입입니다.");
  }

  return baseType;
}

4. 의존성 해결

필요한 준비는 모두 끝났습니다. 이제 GetInstance<T>() 메서드를 만들어 봅시다! 먼저, 의존성을 해결하는 것은 재귀적인 과정입니다. 의존성 그래프를 돌아다니면서 깊숙한 곳에 있는 의존성까지 모두 해결해주어야 하기 때문입니다. 예를 들어, 클래스 X의 의존성을 해결하는 과정은 다음과 같습니다.

- X의 의존성을 해결한다. X는 IA(→ A)와 IB(→ B)에 의존한다.
  - A의 의존성을 해결한다. A는 의존하는 인터페이스가 없다.
  - 의존성이 해결된 A의 인스턴스를 X의 인스턴스에 주입한다.
  - B의 의존성을 해결한다. B는 IC(→ C)에 의존한다.
     - C의 의존성을 해결한다. C는 의존하는 인터페이스가 없다.
     - 의존성이 해결된 C의 인스턴스를 B의 인스턴스에 주입한다.
  - 의존성이 해결된 B의 인스턴스를 X의 인스턴스에 주입한다.

또한, 이 IoC 컨테이너는 생성한 인스턴스를 캐싱합니다. IoC 컨테이너에 새로운 타입을 등록하거나, 기존의 타입을 등록 해제하거나 하는 등의 변동 사항이 생길 때까지 캐싱된 인스턴스들을 유지합니다. 이렇게 하면 생성된 인스턴스들은 하나의 IoC 컨테이너 안에 한해서 싱글톤 인스턴스가 되는 것과 같은 효과를 갖게 됩니다. 앞에서 설명한 대로, 통용되는 IoC 컨테이너는 key를 통해 하나의 클래스에 대한 복수의 인스턴스를 관리할 수 있지만, 여기서는 간결함을 위해 그러한 경우를 고려하지 않았습니다.

아래는 GetInstance<T>() 메서드의 전체 구현입니다.

private readonly Dictionary<Type, object> _instCache;

public T GetInstance<T>() => (T)DoGetInstance(typeof(T));

private object DoGetInstance(Type type)
{
  Type realType = ResolveType(type);

  if (_instCache.TryGetValue(realType, out object obj))
    return (T)obj;

  object newObj = Activator.CreateInstance(realType);
  var props = GetDependencies(realType);

  foreach (var prop in props)
  {
    Type propType = prop.PropertyType;
    object depObj = DoGetInstance(propType); // 재귀호출

    prop.SetValue(newObj, depObj);
  }

  _instCache.Add(realType, newObj);

  return newObj;
}

결과

아래 이미지는 IA, IB, IC와 X에 테스트를 위한 메서드를 정의하고 지금까지 구현한 IoC 컨테이너를 사용한 결과입니다.