Proposal: Implement True Lazy Instantiation in RegisterLazy Method

[xoma-zver]

Summary

Currently, the RegisterLazy method in our dependency injection container actually instantiates the service at the time of registration rather than doing so lazily at the time of first use. This behavior is counterintuitive given the name of the method and does not align with the expected pattern of lazy instantiation.

Proposal

I propose we implement a true lazy instantiation pattern by introducing a LazyActivator class which will defer the creation of the service until it is first requested. This change would ensure that the RegisterLazy method only instantiates the service when it is actually needed, potentially improving performance, especially during startup.

In this case, there are options - to make the activator so that it creates a new instance each time, or to “cache” it. The first option is simpler and limits liability, and caching will be provided by decoration using CachingActivator

# use cache
internal class LazyActivator : ComponentActivator
{
    private readonly Func<object> _factory;
    private object _instance;
    private bool _instantiated;

    public LazyActivator(Func<object> factory)
    {
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
    }

    public override object Activate(DefaultTypeResolver container)
    {
        if (!_instantiated)
        {
            _instance = _factory();
            _instantiated = true;
        }
        return _instance;
    }

    public override ComponentActivator CreateCopy()
    {
        return new LazyActivator(_factory);
    }
}

# use Lazy<T>
internal class LazyActivator : ComponentActivator
{
    private readonly Func<object> _factory;
    private readonly Lazy<object> _lazyInstance;

    public LazyActivator(Func<object> factory)
    {
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
        _lazyInstance = new Lazy<object>(_factory);
    }

    public override object Activate(DefaultTypeResolver container)
    {
        return _lazyInstance.Value;
    }

    public override ComponentActivator CreateCopy()
    {
        return new LazyActivator(_factory);
    }
}

# simple LazyActivator
internal class LazyActivator : ComponentActivator
{
    private readonly Func<object> _factory;

    public NonCachingLazyActivator(Func<object> factory)
    {
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
    }

    public override object Activate(DefaultTypeResolver container)
    {
        return _factory();
    }

    public override ComponentActivator CreateCopy()
    {
        return new NonCachingLazyActivator(_factory);
    }
}

Additionally, the RegisterLazy method would be modified to use this new LazyActivator.

Benefits

• True Lazy Loading: Services are only created when they are actually needed.
• Performance: Can reduce startup time and resource usage by avoiding unnecessary instantiations.

Discussion Points

Are there any scenarios where the current eager instantiation behavior of RegisterLazy is actually desirable?