Make anonymous roots lightweight

[0xivaan]

Hello,

We are going through a very large migration from Unity container to PureDI. Our goal is to improve our startup performance.

Unfortunately due to environmental factors I have no direct control of, a very large portion of the codebase does not really do dependency injection but is using the ServiceLocator pattern as a dependency resolution technic. To make things work I created the following wrapper:

using CommonServiceLocator;
using OfficeSuite.DependencyInjection;
using System;
using System.Collections.Generic;

namespace WordApp.DIConfig
{
    internal class PureDiServiceLocator : IServiceLocator, OfficeSuite.DependencyInjection.IServiceProvider
    {
        private readonly Composition composition;

        public PureDiServiceLocator(Composition composition)
        {
            this.composition = composition;
        }

        public IEnumerable<object> GetAllInstances(Type serviceType)
        {
            throw new NotImplementedException();
        }

        public IEnumerable<TService> GetAllInstances<TService>()
        {
            throw new NotImplementedException();
        }

        public IEnumerable<T> GetAllServices<T>(params IObjectOverride[] objectOverrides)
        {
            throw new NotImplementedException();
        }

        public object GetInstance(Type serviceType)
        {
            return composition.Resolve(serviceType);
        }

        public object GetInstance(Type serviceType, string key)
        {
            return composition.Resolve(serviceType, key);
        }

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

        public TService GetInstance<TService>(string key)
        {
            return (TService)composition.Resolve(typeof(TService), key);
        }

        public object GetService(Type serviceType)
        {
            return composition.Resolve(serviceType);
        }

        public object GetService(Type serviceType, string key, params IObjectOverride[] objectOverrides)
        {
            throw new NotImplementedException();
        }

        public void Teardown()
        {
        }
    }
}

After migrating the first app, I quickly measured the startup time and to my surprise it was actually slower than before (Release build). I'm wondering if the natural cause of this could be that 99% of the registrations have .Root() on them to make things work with that damn locator.

We could of course extend the scope of our task and build up the entire dependency tree at once instead of resolving them like this. But this scope creep has to be justified. I would like to know if we're taking a big performance hit from having so many (99% of our 1300 registrations) end with .Root<T>(). The generated Composition.cs file has about 30k lines of code.

[NikolayPianikov]

Support for lightweight roots

It is necessary to give the opportunity to create lightweight roots. And make anonymous roots lightweight by default.

A simple solution

We can combine the creation of lightweight roots into the creation of a single root with N delegates Func<T>. This will significantly reduce the number of lines of generated code.

For lightweight roots, create a delegate structure, something like:

Roots<T1, T2, ... TN>(Func<T1> factory1, Func<T2> factory2, ... Func<TN> factoryN)

We need to create this root once per composition, i.e. use the Singleton lifetime for it.

The Resolve<T>() and Resolve(Type type)' methods will use these delegates to create instances of the appropriate types.

Important

We need to think about the maximum number of parameters in the C# constructor. Alternatively, use the injection of fields/properties.

[NikolayPianikov]

@0xivaan you can use the above approach to implement the Service lacator, for example using T4 templates (to avoid creating code manually for each root.). But I recommend waiting for the implementation of this feature. I will try not to delay the implementation.

[0xivaan]

@NikolayPianikov I was able to lower down the generated code by 88% (30k -> 3700 loc). This did improve performance significantly. Following your suggestion, I made the Service Locator itself the only composition root, it receives the other services wrapped in Func and exposed them when they were required. Now the startup of our app is about 5% faster than before the migration from Unity started.