What approaches and techniques will you use when creating your own container for dependency injection?

When creating a custom dependency injection container, the following approaches and techniques should be considered:

• Dependency registration: implement methods for registering types and their implementations, for example, with different lifecycles (singleton, transient).
• Dependency resolution: the container should be able to create objects, automatically resolving their dependencies through constructors (constructor injection).
• Recursive resolution: when creating an object, the container should recursively create all necessary dependencies.
• Handling cyclic dependencies: provide protection against infinite recursion.
• Configuration: ability to configure dependencies through code or configuration files.

Example of a simplified container in C#:

public class SimpleContainer
{
    private readonly Dictionary<Type, Type> _registrations = new();

    public void Register<TService, TImplementation>()
    {
        _registrations[typeof(TService)] = typeof(TImplementation);
    }

    public TService Resolve<TService>()
    {
        return (TService)Resolve(typeof(TService));
    }

    private object Resolve(Type serviceType)
    {
        if (!_registrations.ContainsKey(serviceType))
            throw new Exception($"Service {serviceType.Name} not registered");

        var implementationType = _registrations[serviceType];
        var constructor = implementationType.GetConstructors().First();
        var parameters = constructor.GetParameters()
            .Select(p => Resolve(p.ParameterType))
            .ToArray();

        return Activator.CreateInstance(implementationType, parameters);
    }
}

This container allows registering dependencies and automatically creating objects with their dependencies.