Can I achieve the functionality of nested/child container with StrongInject?

[ekalchev]

I am trying to replace Unity DI container and I need to know if it is possible to implement child container functionality. Child containers allow you to register singleton instances in the scope of the child container so you can end up with multiple singletons for each child container and every instance resolved from the child container will use that singleton instance. Child containers inherit all registrations from their parent containers.

[YairHalberstadt]

Hi @ekalchev there are various mechanisms that can be used to achieve something similar, but first I have to understand what you're trying to achieve.

If the purpose is purely to reduce the scope of some dependencies, then the InstancePerResolution scope might be appropriate. This creates a new instance every time you resolve the instance at a different time (e.g. by use of a Func), but shares any instances that are all resolved at once (e.g. if both b and c depend on a, and d depends on b and c, then if you resolve d, both b and c will share instances of a.

If that's not exactly what you need, please let me know more exactly what semantics you need, and I can try and guide you in the right direction.

[ekalchev]

@YairHalberstadt, one per account

[YairHalberstadt]

Understood. It's getting late here so I'll hopefully reply to you tomorrow

[YairHalberstadt]

Here's an example of code that should do what you want:

using StrongInject;
using System;
using System.Collections.Generic;

var container = new Container();
container.Run(app =>
{
    var user1 = new UserName("Joe", "Blogs");
    var user2 = new UserName("Ploni", "Almoni");
    var account1 = app.OnUser(user1);
    using var account2 = app.OnUser(user2);
    var account3 = app.OnUser(user1);
    account1.Dispose();
    account3.Dispose();
    using var account4 = app.OnUser(user1);
});

public record UserName(string FirstName, string LastName);

public interface IDbRepository : IDisposable
{
    
}

public class DbRepository : IDbRepository
{
    private readonly UserName _user;

    public DbRepository(UserName user)
    {
        Console.WriteLine("Creating a new repository for " + user);
        _user = user;
    }

    public void Dispose(){}
}

public class AccountService
{
    public IDbRepository Repository {get;}
    public AccountService(Func<IDbRepository> repositoryFactory)
    {
        Repository = repositoryFactory();
    }
}

public class EmailAccount
{
    public EmailAccount(Func<IDbRepository> repositoryFactory, Func<AccountService> accountServiceFactory)
    {
        Console.WriteLine("Do we share repositories? " + object.ReferenceEquals(repositoryFactory(), accountServiceFactory().Repository));
    }
}

public class RepositoryWrapper : IDisposable
{
    private readonly Action _dispose;
    private readonly object _lock;

    public RepositoryWrapper(IDbRepository repository, Action dispose, object @lock)
    {
        _dispose = dispose;
        _lock = @lock;
        _repository = repository;
    }

    public IDbRepository Repository
    {
        get
        {
            lock (_lock)
            {
                _referenceCount++;
            }

            return _repository;
        }
    }

    private int _referenceCount;
    private readonly IDbRepository _repository;

    public void Dispose()
    {
        lock (_lock)
        {
            _referenceCount--;
            if (_referenceCount == 0)
            {
                _dispose();
            }
        }
    }
}

public class MyApp
{
    private readonly Func<UserName, Owned<EmailAccount>> _getAccount;

    public MyApp(Func<UserName, Owned<EmailAccount>> getAccount)
    {
        _getAccount = getAccount;
    }

    public Owned<EmailAccount> OnUser(UserName user)
    {
        return _getAccount(user);
    }
}

[Register(typeof(MyApp))]
[Register(typeof(EmailAccount))]
[Register(typeof(AccountService))]
partial class Container : IContainer<MyApp>
{
    private readonly Dictionary<UserName, RepositoryWrapper> _cache = new();
    private readonly object _lock = new();
    [Factory] RepositoryWrapper GetRepositoryWrapper(UserName user)
    {
        lock (_lock)
        {
            if (_cache.TryGetValue(user, out var repository))
            {
                return repository;
            }

            repository = new(new DbRepository(user), () =>
            {
                lock (_lock)
                {
                    _cache.Remove(user);
                }
                repository!.Repository.Dispose();
            }, _lock);
            
            _cache.Add(user, repository);

            return repository;
        }
    }

    [Factory] IDbRepository GetRepository(RepositoryWrapper wrapper) => wrapper.Repository;
}

It prints:

Creating a new repository for UserName { FirstName = Joe, LastName = Blogs }
Do we share repositories? True
Creating a new repository for UserName { FirstName = Ploni, LastName = Almoni }
Do we share repositories? True
Do we share repositories? True
Creating a new repository for UserName { FirstName = Joe, LastName = Blogs }
Do we share repositories? True

[ekalchev]

Thanks for your time to help me with this. If I understand correctly with suggested approach I should have Dictionary and Wrapper class for each dependency which is account scoped?

[YairHalberstadt]

@ekalchev yes, that is correct, although you could easily make the wrapper class generic.

To reduce boilerplate even further you could also have a dictionary of dictionaries from types to the cache, and then use the [FactoryOf] attribute to only use the factory methods for specific types.