How to resolve type with dependency that is known only runtime?

[ekalchev]

How to resolve a type A which depends on instance of type B, but B can be constructed only runtime from the user input?

Usually DI containers do that by injecting into user class Func<B,A> and in the implementation of Func<B,A> you can do something like

A FactoryMethod(B b)
{
     return container.Resolve<A>(new DependencyOverride<B>(b);
}

This tells the container to use provided B instance when resolving the graph, instead of looking for registration of type B in the container.

[YairHalberstadt]

What does the user input look like?

[YairHalberstadt]

Also, in the case where you know the user input before you create your container, you can just pass it as a parameter to the container and mark the field where you store it as an [Instance].

[ekalchev]

Ok, I can't get this working. I tried this

using System;
using System.Diagnostics;
using StrongInject;

namespace StrongInjectTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var accountContainer1 = new AccountContainer();
            var account1Service = accountContainer1.Resolve<AccountService>().Value;
        }
    }

    public class ApplicationService1
    {
        private readonly UserInput userInput;

        public ApplicationService1(UserInput userInput)
        {
            this.userInput = userInput;
        }
    }

    public class UserInput
    {
        private readonly string input;

        public UserInput(string input)
        {
            this.input = input;
        }
    }

    public class AccountService
    {
        private readonly Func<UserInput, ApplicationService1> factory;

        public AccountService(Func<UserInput, ApplicationService1> factory)
        {
            this.factory = factory;
        }

        public ApplicationService1 ApplicationService1
        {
            get
            {
                // lets say we read user input here and create the dependency runtime
                // I would like pass this instance to the container and container to use it for resolve the dependency graph with that instance
                return factory(new UserInput("asdasdsad"));
            }
        }
    }

    [Register(typeof(AccountService), Scope.SingleInstance)]
    [Register(typeof(ApplicationService1), Scope.SingleInstance)]
    public partial class AccountContainer : IContainer<AccountService>
    {
        public AccountContainer()
        {
        }
    }
}

[YairHalberstadt]

The problem is that ApplicationService1 is registered as SingleInstance, so it's impossible to create a new instance every time UserInput changes.

[ekalchev]

Great, that actually worked! Here is working example - this is equivalent of DependencyOverride in Unity IOC

using System;
using System.Diagnostics;
using StrongInject;

namespace StrongInjectTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var accountContainer1 = new AccountContainer();
            var account1Service = accountContainer1.Resolve<AccountService>().Value;

            var appservice1 = account1Service.ApplicationService1;
            var appservice2 = account1Service.ApplicationService1;

            Debug.Assert(ReferenceEquals(appservice1.UserInput, appservice1.ApplicationServiceDependency.UserInput));
            Debug.Assert(ReferenceEquals(appservice2.UserInput, appservice2.ApplicationServiceDependency.UserInput));

            Debug.Assert(ReferenceEquals(appservice1.UserInput, appservice2.UserInput) == false);
            Debug.Assert(ReferenceEquals(appservice1.ApplicationServiceDependency.UserInput, appservice2.ApplicationServiceDependency.UserInput) == false);
        }
    }

    public class ApplicationService1
    {
        public ApplicationService1(UserInput userInput, ApplicationServiceDependency applicationServiceDependency)
        {
            UserInput = userInput;
            ApplicationServiceDependency = applicationServiceDependency;
        }

        public UserInput UserInput { get; }
        public ApplicationServiceDependency ApplicationServiceDependency { get; }
    }

    public class ApplicationServiceDependency
    {
        public ApplicationServiceDependency(UserInput userInput)
        {
            UserInput = userInput;
        }

        public UserInput UserInput { get; }
    }

    public class UserInput
    {
        private readonly string input;

        public UserInput(string input)
        {
            this.input = input;
        }
    }

    public class AccountService
    {
        private readonly Func<UserInput, ApplicationService1> factory;

        public AccountService(Func<UserInput, ApplicationService1> factory)
        {
            this.factory = factory;
        }

        public ApplicationService1 ApplicationService1
        {
            get
            {
                // lets say we read user input here and create the dependency runtime
                // I would like pass this instance to the container and container to use it for resolve the dependency graph with that instance
                return factory(new UserInput("asdasdsad"));
            }
        }
    }

    [Register(typeof(AccountService), Scope.InstancePerDependency)]
    [Register(typeof(ApplicationService1), Scope.InstancePerDependency)]
    [Register(typeof(ApplicationServiceDependency), Scope.InstancePerDependency)]
    public partial class AccountContainer : IContainer<AccountService>
    {
        public AccountContainer()
        {
        }
    }
}

[YairHalberstadt]

Glad to hear it!