Console.WriteLine("Hello, World!");

MyIocContainer services = new MyIocContainer();

services.AddTransient<ITestService, TestService>();
services.AddTransient<IMyService, MyService>();



var myService = services.GetService<IMyService>();




public class MyIocContainer
{

    Dictionary<Type, Type> _container = new();
    public void AddTransient<TInterface, TImplement>()
    {
        if (_container.ContainsKey(typeof(TInterface)))
        {
            _container.Remove(typeof(TInterface));
        }

        _container.Add(typeof(TInterface), typeof(TImplement));
    }

    public T GetService<T>()
    {

        return (T)GetService(typeof(T), _container);
    }

    private static object GetService(Type interfaceType, Dictionary<Type, Type> container)
    {
        if (!container.ContainsKey(interfaceType))
        {
            throw new Exception($"there is no implement type of {interfaceType.Name}");
        }

        var implementType = container[interfaceType];
        var ctors = implementType.GetConstructors();
        var constructor = ctors.OrderByDescending(x => x.GetParameters().Count()).FirstOrDefault();
        if (constructor is null)
        {
            throw new ArgumentNullException(nameof(constructor));
        }

        var ctorParameters = constructor.GetParameters();

        List<object> parameterList = new();
        foreach (var p in ctorParameters)
        {
            var parameterInterfaceType = p.ParameterType;
            parameterList.Add(GetService(parameterInterfaceType, container));
        }

        return constructor.Invoke(parameterList.ToArray());
    }
}




public interface IMyService { }

public class MyService : IMyService
{
    public MyService(ITestService testService)
    {

    }
}


public interface ITestService { }
public class TestService : ITestService
{

}