dependency injection – Using Autofac with static services class

I am using Autofac to maximise the sharing of code between Android and iOS via a shared PCL assembly in a Xamarin (native) environment. The shared service layer consists of four interfaces to classes containing methods or data that don’t change throughout the lifetime of the application.

Instead of resolving the service classes from the Autofac singleton container at every point of use, I’ve thought of creating a class of static references to the services.

I would like to know whether there is something intrinsically wrong with this approach (e.g. memory leaks), or if there is some better suggestion someone could make.

This is the gist:

Android (& equivalent iOS):

public class BootStrap
{
    private static IContainer container = null;
    public static IContainer Container()
    {
        if (container == null)
        {
            ContainerBuilder builder = new ContainerBuilder();
            builder.RegisterType<CacheFactory>().SingleInstance().As<ICacheFactory>(); ;
            builder.RegisterType<ClientFactory>().SingleInstance().As<IClientFactory>();
            builder.RegisterType<CoreHelpers>().SingleInstance().As<ICoreHelpers>();
            builder.RegisterType<PrefsSerializer>().SingleInstance().As<IPrefsSerializer>();
            builder.RegisterType<Services>().SingleInstance();
            container = builder.Build();
        }
        return container;
    }
}

public class MainApp
{
    private ILifetimeScope RootScope;

    public MainApp
    {
        RootScope = BootStrap.Container().BeginLifetimeScope();         // register types, return container
        RootScope.Resolve<Services>();                                  // set static Services members
    }

    ~MainApp()
    {
        RootScope.Dispose();
    }
}

Shared Assembly:

public class Services
{
    public static ICacheFactory CacheFactory;       // data and methods
    public static IClientFactory ClientFactory;     // data and methods
    public static ICoreHelpers CoreHelpers;         // methods only
    public static IPrefsSerializer PrefsHelper;     // methods only

    public Services(ICacheFactory _cacheFactory, IClientFactory _clientFactory, ICoreHelpers _coreHelpers, IPrefsSerializer _prefsHelper)
    {
        CacheFactory = _cacheFactory;
        ClientFactory = _clientFactory;
        CoreHelpers = _coreHelpers;
        PrefsHelper = _prefsHelper;
    }
}

Usage:

Services.CacheFactory.GetCache().DoSomething();
UserClient user = Services.ClientFactory.GetUserClient();
...