Come modificare la registrazione delle dipendenze in fase di esecuzione utilizzando l'iniettore semplice?

Question

Sto utilizzando il framework IoC Simple Injector e vorrei poter modificare la registrazione delle dipendenze in fase di esecuzione. Ad esempio, ho due implementazioni, A e B, dell'interfaccia I. L'implementazione A è registrata all'avvio dell'app, ma a seconda di alcuni flag che possono cambiare durante il runtime, vorrei passare all'implementazione. Attualmente stiamo facendo questo l'evento OnActionExecuting del nostro BaseController, da cui tutti i nostri controllori ereditano. Ecco il codice di esempio di ciò che sto cercando di fare.

protected override void OnActionExecuting(
    ActionExecutingContext filterContext) 
{ 
    if (IsRuntimeFlag) 
    { 
     // check current implementation type and 
     // change implementation to A 
    } 
    else 
    { 
     // check current implementation type and 
     // change implementation to B 
    } 

    base.OnActionExecuting(filterContext); 
} 

Grazie in anticipo per il vostro aiuto.

Answer 1

In caso IsRuntimeFlag è un valore di configurazione (quindi non può cambiare durante la vita dell'applicazione), è possibile effettuare la registrazione come segue:

if (IsRuntimeFlag) 
{ 
    container.Register<I, A>(); 
} 
else 
{ 
    container.Register<I, B>(); 
} 

o ugualmente:

container.Register(typeof(I), IsRuntimeFlag ? typeof(A) : typeof(B)); 

Nel caso in cui il valore può cambiare durante la vita dell'applicazione un proxy o composite che si occupa dell'erogazione all'istanza giusta è la soluzione giusta:

public sealed class RuntimeFlagIComposite : I 
{ 
    private readonly A a; 
    private readonly B b; 

    public RuntimeFlagIComposite(A a, B b) { 
     this.a = a; 
     this.b = b; 
    } 

    void I.Method() => this.Instance.Method(); 

    private I Instance => IsRuntimeFlag ? this.a : this.b; 
} 

Perché il composito dipende direttamente A e B, si può semplicemente registrarsi come segue:

container.Register<I, RuntimeFlagIComposite>(); 

Quando A o B hanno una vita diversa da quella transitoria (una nuova istanza per ogni richiesta), è dovrebbe anche registrarli. Per esempio:

container.Register<A>(Lifestyle.Singleton); 
container.Register<B>(Lifestyle.Scoped); 

Si può anche lasciare il vostro composito dipendono dalla I astrazione stesso anziché calcestruzzo A e B implementazioni:

public class RuntimeFlagIComposite : I 
{ 
    private I a; 
    private I b; 

    public RuntimeFlagIComposite(I a, I b) 
    { 
     this.a = a; 
     this.b = b; 
    } 
} 

A seconda del I astrazione rende questa classe più flessibile e più verificabile. Significa tuttavia che è necessario registrarlo un po 'diverso:

container.Register<I, RuntimeFlagIComposite>(); 

container.RegisterConditional<I, A>(c => c.Consumer.Target.Name == "a"); 
container.RegisterConditional<I, B>(c => c.Consumer.Target.Name == "b");