😊나만의 MVVM 라이브러리 제작 과정. ConvMVVM #1 - IoCContainer

gellston · 12월 31, 2023, 8:20오전

나만의 MVVM 라이브러리 만들기 #1 IOC Container

MVVM Toolkit과 Prism의 장점을 섞기 위한 고난과 역경 ㅠ

ConvMVVM 소스코드

블로그 글 링크

동기

저는 사실 C#개발 경력이 짧습니다.
그래도 요즘 재미가 들려서 이것저것 보고있는데 문득 드는 생각이… 이런것들을 쓰는 것도 중요하지만 이런 기능들을 내가 구현을 못하면 내것이 아니라는 생각이 들더군요
늦었지만 조금씩 나만의 MVVM라이브러리를 만들어보면서 기회가 된다면 다른 라이브러리에는 없는 서비스나 감초같은 기능을 넣어보고자 합니다.

주변 지인분들 말을 들어보면 IOC컨테이너 종류도 다양하다고 들었는데 많은 것들을 접하진 못했고… 제가 개발할때 주로 사용하는 IOC 컨테이너는 Microsoft Extensions DependencyInjection 입니다
제가 구현하고자하는 대부분의 IOC의 기능은 Microsoft Extensions DependencyInjection과 닮아있습니다.

구현하고자 하는 기능

Cache객체와 NoneCache객체 등록 (Singleton, Transient)
Interface와 같이 객체를 등록
생성자 주입
미리 생성한 객체를 등록
람다를 이용한 객체 생성 루틴 등록

참고자료

Carlos Blanco님의 포스트를 참고 했습니다.

고려하지 않은 사항 및 한계

정량적인 수치를 가지고 다른 유명한 라이브러리들과 성능등을 비교하지는 않았습니다… 감히…제가…
처음에도 언급드렸다시피 초보기 때문에 코드가 지저분합니다
버그가 있을 수 있습니다.

구현 과정

1. 서비스 등록을 위한 인터페이스

namespace ConvMVVM.Core.IOC
{
    public interface IServiceCollection
    {
        public void RegisterCache<TInterface, TImplementation>() where TImplementation : TInterface;
				//인터페이스와 구상체 클래스를 같이 등록하기 위한 함수

        public void RegisterNoneCache<TInterface, TImplementation>() where TImplementation : TInterface;

        public void RegisterCache<TImplementation>() where TImplementation : class;
				//구상체 클래스만으로 등록하기 위한 함수

        public void RegisterCache<TImplementation>(TImplementation implementation) where TImplementation : class;
				//미리 생성한 클래스를 등록하기 위한 함수

        public void RegisterNoneCache<TImplementation>() where TImplementation : class;

        public void RegisterCache<TInterface, TImplementation>(TImplementation implementation) where TImplementation : TInterface;

        public void RegisterCache<TInterface, TImplementation>(Func<IContainer, TInterface> factory) where TImplementation : TInterface;
				//람다를 이용한 서비스 생성 루틴 등록을 위한 함수

        public void RegisterNoneCache<TInterface, TImplementation>(Func<IContainer, TInterface> factory) where TImplementation : TInterface;

        public void RegisterCache<TImplementation>(Func<IContainer, TImplementation> factory) where TImplementation : class;
        public void RegisterNoneCache<TImplementation>(Func<IContainer, TImplementation> factory) where TImplementation : class;


        public bool CheckType(Type type);
				//Container에서 타입 존재 유무 판별용 함수


        public Tuple<Type, bool, object, object> GetType(Type type);
				//ServiceCollection에 타입을 키로 등록된 정보를 가져오는 함수 

        public IContainer CreateContainer();
				//컨테이너 생성을 위한 함수 
    }
}

public void RegisterCache<TInterface, TImplementation>() where TImplementation : TInterface;

public void RegisterCache<TImplementation>() where TImplementation : class;

개인적으로 만들면서 특히나 흥미로웠던 부분은 이 부분인데. generic TImplementation이 TInterface의 상속이 필요하다는 제한을 걸수 있다는 것이다.
음……. 그런데 그와 동시에 TInterface가 interface면서 TImplementation이 class여야함을 제한하는 것은 안되는 것인가?…
공부를 덜한 것인지 원래 안되는 것인지… 여러가지 생각이 들었습니다.

2. 서비스 컨테이너를 위한 인터페이스

namespace ConvMVVM.Core.IOC
{
    public interface IContainer
    {
        public TInterface GetService<TInterface>() where TInterface: class;
    }
}

북어국 마냥 담백하게 하나의 함수만 넣었습니다.

3. ServiceCollection 구현

namespace ConvMVVM.Core.IOC
{
    public class ServiceCollection : IServiceCollection
    {
        #region Private Property
        private readonly Dictionary<Type, Tuple<Type, bool, object, object>> Types = new Dictionary<Type, Tuple<Type, bool, object, object>>();
        #endregion

        #region Constructor
        internal ServiceCollection()
        {

        }
        #endregion

        #region Static Functions
        public static IServiceCollection Create()
        {
            return new ServiceCollection();
        }
        #endregion

        #region Private Functions
        private Tuple<Type, bool, object, object> CreateTypeInfo(Type type, bool cache, object cacheObject, object callback )
        {
            return new Tuple<Type, bool, object, object>(type, cache, cacheObject, callback);
        }
        #endregion

        #region Public Functions
        public void RegisterCache<TInterface, TImplementation>() where TImplementation : TInterface
        {
            this.Types[typeof(TInterface)] = this.CreateTypeInfo(typeof(TImplementation), true, null, null);
        }

        public void RegisterCache<TImplementation>() where TImplementation : class
        {
            this.Types[typeof(TImplementation)] = this.CreateTypeInfo(typeof(TImplementation), true, null, null);
        }

        public void RegisterCache<TImplementation>(TImplementation implementation) where TImplementation : class
        {
            this.Types[typeof(TImplementation)] = this.CreateTypeInfo(typeof(TImplementation), true, implementation, null);
        }

        public void RegisterNoneCache<TInterface, TImplementation>() where TImplementation : TInterface
        {
            this.Types[typeof(TInterface)] = this.CreateTypeInfo(typeof(TImplementation), false, null, null);
        }

        public void RegisterNoneCache<TImplementation>() where TImplementation : class
        {
            this.Types[typeof(TImplementation)] = this.CreateTypeInfo(typeof(TImplementation), false, null, null);
        }

        public void RegisterCache<TInterface, TImplementation>(TImplementation implementation) where TImplementation : TInterface
        {
            this.Types[typeof(TInterface)] = this.CreateTypeInfo(typeof(TImplementation), true, implementation, null);
        }

        public void RegisterCache<TInterface, TImplementation>(Func<IContainer, TInterface> factory) where TImplementation : TInterface
        {
            this.Types[typeof(TInterface)] = this.CreateTypeInfo(typeof(TImplementation), true, null, factory);
        }

        public void RegisterNoneCache<TInterface, TImplementation>(Func<IContainer, TInterface> factory) where TImplementation : TInterface
        {
            this.Types[typeof(TInterface)] = this.CreateTypeInfo(typeof(TImplementation), false, null, factory);
        }

        public void RegisterCache<TImplementation>(Func<IContainer, TImplementation> factory) where TImplementation : class
        {
            this.Types[typeof(TImplementation)] = this.CreateTypeInfo(typeof(TImplementation), true, null, factory);
        }
        public void RegisterNoneCache<TImplementation>(Func<IContainer, TImplementation> factory) where TImplementation : class
        {
            this.Types[typeof(TImplementation)] = this.CreateTypeInfo(typeof(TImplementation), false, null, factory);
        }

        public bool CheckType(Type type)
        {
            if (this.Types.ContainsKey(type)) return true;
            else return false;
        }

        public IContainer CreateContainer()
        {
            return new Container(this);
        }

        public Tuple<Type, bool, object, object> GetType(Type type)
        {
            if (!CheckType(type))
            {
                throw new InvalidOperationException("Invalid key type");
            }

            return this.Types[type];
        }


        #endregion
    }
}

#region Private Property
												//타입키,  튜플(구상체 타입, cache유무, cache오브젝트, 생성루틴 주입을 위한 람다 콜백)
private readonly Dictionary<Type, Tuple<Type, bool, object, object>> Types = new Dictionary<Type, Tuple<Type, bool, object, object>>();
#endregion

Dictionary로 타입키를 키로 튜플로 생성에 필요한 정보를 묶어서 넣을 수 있도록 Types라는 Dictionary를 만들었습니다.

#region Private Functions
																												//객체 타입, cache 유무, cache 오브젝트, 생성루틴 lambda
private Tuple<Type, bool, object, object> CreateTypeInfo(Type type, bool cache, object cacheObject, object callback )
{
    return new Tuple<Type, bool, object, object>(type, cache, cacheObject, callback);
}
#endregion

각 인터페이스 함수에 맞게 튜블 정보를 만들어서 Dictionary에 등록을 했습니다.
이 정보를 이용해서 Container에서 객체를 생성할것입니다.

//내가 만들 타입이 있는지 확인
public bool CheckType(Type type)
{
    if (this.Types.ContainsKey(type)) return true;
    else return false;
}

public IContainer CreateContainer()
{
    return new Container(this);
}

//타입이 있다면 그 타입의 생성을 위해 필요한 정보를 가져오기. 
public Tuple<Type, bool, object, object> GetType(Type type)
{
    if (!CheckType(type))
    {
        throw new InvalidOperationException("Invalid key type");
    }

    return this.Types[type];
}

그 외 기타 객체 생성을 위해 필요한 타입 존재 유무 체크 함수와, 타입의 등록정보를 가져오는 함수도 만듭니다.

4. Container 구현

namespace ConvMVVM.Core.IOC
{
    public class Container : IContainer
    {
        #region Private Property
        private readonly IServiceCollection serviceCollection;
        private readonly Dictionary<Type, object> cacheObjects = new Dictionary<Type, object>();
        #endregion

        #region Constructor
        public Container(IServiceCollection services)
        {
            if(services == null)
            {
                throw new InvalidOperationException("Invalid service collection");
            }
            this.serviceCollection = services;
        }
        #endregion


        #region Private Functions
        public object Create(Type type)
        {
            if (!this.serviceCollection.CheckType(type))
            {
                throw new InvalidOperationException("There is no service key");
            }
            try
            {

                var typeInfo = this.serviceCollection.GetType(type);

                var objectType = typeInfo.Item1;
                var cacheOrNot = typeInfo.Item2;
                var cacheObject = typeInfo.Item3;
                var callback = typeInfo.Item4;
                var defaultConstructors = objectType.GetConstructors();
                if(defaultConstructors.Count() <= 0 && cacheObject == null)
                {
                    throw new InvalidOperationException("There is no constructor");
                }

                if (cacheOrNot == false && callback == null && cacheObject == null)
                {
                    var defaultConstructor = defaultConstructors[0];
                    var defaultParams = defaultConstructor.GetParameters();
                    var parameters = defaultParams.Select(param => Create(param.ParameterType)).ToArray();
                    var service = defaultConstructor.Invoke(parameters);
                    return service;
                }
                
                if(cacheOrNot == false && callback != null && cacheObject == null)
                {
                    var methodInfo = callback.GetType().GetMethod("Invoke");
                    var service = methodInfo.Invoke(callback, new[] { this });
                    return service;
                }

                if(cacheOrNot == true && callback == null && cacheObject == null)
                {
                    if (this.cacheObjects.ContainsKey(type) == true)
                        return this.cacheObjects[type];

                    var defaultConstructor = defaultConstructors[0];
                    var defaultParams = defaultConstructor.GetParameters();
                    var parameters = defaultParams.Select(param => Create(param.ParameterType)).ToArray();
                    var service = defaultConstructor.Invoke(parameters);
                    this.cacheObjects[type] = service;
                    return service;
                }

                if(cacheOrNot == true && callback != null && cacheObject == null)
                {
                    if (this.cacheObjects.ContainsKey(type) == true)
                        return this.cacheObjects[type];

                    var methodInfo = callback.GetType().GetMethod("Invoke");
                    var service = methodInfo.Invoke(callback, new[] { this });
                    this.cacheObjects[type] = service;
                    return service;
                }

                if (cacheOrNot == true && callback == null && cacheObject != null)
                {
                    if (this.cacheObjects.ContainsKey(type) == true)
                        return this.cacheObjects[type];

                    this.cacheObjects[type] = cacheObject;
                    return cacheObject;
                }

                throw new InvalidOperationException("Invalid service collection infomation");
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("Unknown", ex);
            }
        }
        #endregion

        #region Functions

        public TInterface GetService<TInterface>() where TInterface : class
        {
            try
            {
                return (TInterface)Create(typeof(TInterface));
            }catch(Exception ex)
            {
                throw new InvalidOperationException("Unknown", ex);
            }
        }

        #endregion
    }
}

가장 중요한 부분은 public object Create(Type type) 이 함수인데 각 객체 생성에 필요한 정보에 맞춰 객체를 생성합니다.
총 5가지정도의 경우가 발생하는데

cache==false, cache오브젝트가 없으며 생성루틴 callback이 없다면 → reflection을 이용하여 NoneCache로 객체 생성

cache==false, cache오브젝트가 없으며 생성루틴 callback이 있다면 → reflection을 이용하여 NoneCache를 callback으로 생성

cache==true, cache오브젝트가 없으며 생성루틴 callback이 없다면 → reflection을 이용하여 Cache객체를 만들고 Cache객체 테이블에 등록하여 수명관리

cache==true, cache오브젝트가 있으며 생성루틴 callback이 없다면 → cache오브젝트를 그대로 Cache객체 테이블에 등록하여 수명관리

cache==true, cache오브젝트가 없으며 생성루틴 callback이 있다면 → reflection을 이용하여 Cache객체를 callback으로 생성, Cache객체 테이블에 등록하여 수명관리

위와 같은 로직으로 생성되며… 생성자 주입을 위해서 Reflection과 Create함수를 재귀적으로 Linq의 Select와 같이 섞어서 >호출합니다.
그러면 각 생성자에 필요한 객체를 생성자 주입한 상태로 생성하게 됩니다.

IOC컨테이너 사용

만들어봤으니 이제는 써봐야 합니다…
IOC컨테이너를 쓰는 여러가지 방법이 있겠지만… 제가 개인적으로 개발하면서 느꼈던 쓰임새를 정리하여 아래와 같은 케이스로 나눠봤습니다.

사례 #1인터페이스가 상속된, 서비스를 생성자 주입 객체
사례 #2 A Model을 품고 있는 A ViewModel 생성 하지만 A Model은 Ioc등록을 하고 싶지 않을때
사례 #3 A Model을 품고 있는 A ViewModel 묶음을 생성 하지만 A Model은 Ioc등록을 하고 싶지 않을때
사례 #4 A, B, C Model을 Property 주입을 받아서 D ViewModel 생성. 하지만 A, B, C모델은 IoC등록을 하고 싶지 않을때

사례 #1

인터페이스가 상속된, 서비스를 생성자 주입한 객체

//TestModel 
namespace IOCContainerExample.Model
{
    public class TestModel : ITestModel
    {
        #region Private Property
        private readonly TestService testService;
        #endregion

        #region Constructor
        public TestModel(TestService _testService) { 
            this.testService = _testService;
        }
        #endregion

        #region Functions
        public string Test()
        {
            return this.testService.Test();
        }
        #endregion
    }
}

TestModel 클래스 구현부

namespace IOCContainerExample.Service
{
    public class TestService
    {

        #region Consturctor
        public TestService() { }
        #endregion

        #region Public Property
        public string Test()
        {
            return "there is no cow level";
        }
        #endregion
    }
}

TestService 클래스 구현부

var collection = ServiceCollection.Create();
collection.RegisterCache<TestService>();
collection.RegisterCache<ITestModel, TestModel>();

var container = collection.CreateContainer();
var tesetModel = container.GetService<ITestModel>();

System.Console.WriteLine(tesetModel.Test());

IoC컨테이너 등록 및 객체 생성 사용… 이정도는 IoC 쓰시는 분이라면 잘 알고 계실겁니다.

사례 #2

A Model을 품고 있는 A ViewModel 생성 하지만 A Model은 IoC등록을 하고 싶지 않을때.

namespace IOCContainerExample.Model
{
    public class AModel
    {
        #region Constructor
        public AModel() { }
        #endregion
    }
}

AModel 클래스 구현부

namespace IOCContainerExample.ViewModel
{
    public class AViewModel
    {
        #region Constructor
        public AViewModel()
        {

        }
        #endregion

        #region Public Property
        public AViewModel AModel { get; set; }
        #endregion
    }
}

AViewModel 클래스 구현부

var collection = ServiceCollection.Create();
collection.RegisterCache<AViewModel>();
collection.RegisterNoneCache<Func<AModel, AViewModel>>((container)=>
{
    return (model) =>
    {
        var vm = container.GetService<AViewModel>();
        vm.AModel = model;
        return vm;
    };
});

var container = collection.CreateContainer();
var converter = container.GetService<Func<AModel, AViewModel>>();
var model = new AModel();
var viewModel = converter(model);

System.Console.WriteLine("test");

이 경우를 위해서 Microsoft Extensions DependencyInjection 에서 람다 생성을 지원하나 봅니다…

사례 #3

A Model을 품고 있는 A ViewModel 묶음을 생성 하지만 A Model은 Ioc등록을 하고 싶지 않을때

var collection = ServiceCollection.Create();
collection.RegisterCache<AViewModel>();
collection.RegisterNoneCache<Func<AModel, AViewModel>>((container) =>
{
    return (model) =>
    {
        var vm = container.GetService<AViewModel>();
        vm.AModel = model;
        return vm;
    };
});
collection.RegisterNoneCache<Func<List<AModel>, List<AViewModel>>>((container) =>
{
    return (models) =>
    {
        var converter = container.GetService<Func<AModel, AViewModel>>();
        var vms = models.Select(model => converter(model)).ToList();
        return vms;
    };
});

var container = collection.CreateContainer();
var converter = container.GetService<Func<List<AModel>, List<AViewModel>>>();

var models = new List<AModel>()
{
    new AModel(),
    new AModel(),
    new AModel()
};
var viewModels = converter(models);

사례 #4

A, B, C Model을 Property 주입을 받아서 D ViewModel 생성. 하지만 A, B, C모델은 IoC등록을 하고 싶지 않을때

var collection = ServiceCollection.Create();
collection.RegisterCache<DViewModel>();
collection.RegisterNoneCache<Func<AModel, BModel, CModel, DViewModel>>((container) =>
{
    return (amodel, bmodel, cmodel) =>
    {
        var vm = container.GetService<DViewModel>();
        vm.AModel = amodel;
        vm.BModel = bmodel;
        vm.CModel = cmodel;
        return vm;
    };
});

var container = collection.CreateContainer();


var amodel = new AModel();
var bmodel = new BModel();
var cmodel = new CModel();

var converter = container.GetService<Func<AModel, BModel, CModel, DViewModel>>();
var viewModel = converter(amodel, bmodel, cmodel);

라이브러리에서 Property Injection을 지원하지않더라도 람다 주입을 통해서 어느정도 극복이 가능합니다.

앞으로 추가 혹은 개선되어야 될 사항

위 예제에서도 보다시피 Property Injection을 지원하는 Attribute가 있으면 좋을 것 같다는 생각을 했습니다.
다른 IoC 컨테이너에서는 지원을 하는것 같던데…
Microsoft Extensions DependencyInjection 에서 지원을 안하는 이유는 모르겠으나 아마도 람다를 이용해서 가능하기 때문이 아닐가요?

Chris_Shim · 12월 31, 2023, 8:32오전

훌륭하네요.
MSDI에 대한 궁금점은 다음책을 보시면 좋을 거 같아요.

gellston · 12월 31, 2023, 8:35오전

감사합니다. 정독해봐야겠네요 감사합니다!