Dipendenza circolare nell'integrazione delle dipendenze

Ho intenzione di astrarre significativamente dalla tua situazione. Non sono sicuro se questa sarà la migliore soluzione al tuo problema. Sarà una soluzione a , ma potrebbe semplicemente consentire una progettazione scadente. È difficile da dire, ma certamente la situazione si presenta in termini ragionevoli.

È abbastanza comune che ti trovi in una situazione in cui costruire X hai bisogno di Y , e per costruire Y hai bisogno di X . Naturalmente, non può essere che concettualmente costruire X è necessario aver completamente creato un Y e viceversa, altrimenti sarebbe logicamente impossibile costruire il sistema. Invece, ciò che è veramente inteso è costruirne uno, è semplicemente necessario un modo di riferirsi all'altro. Ci sono molti modi di riferirsi a qualcosa che non è stato ancora creato. Ad esempio, in C è possibile passare un puntatore alla memoria allocata ma non inizializzata oppure è possibile passare una stringa che verrà utilizzata per cercare l'oggetto creato in un registro. In un linguaggio come Haskell o Scala, un modo per risolvere questo è con la valutazione pigra. Per quanto riguarda l'implementazione, questo è più o meno equivalente a passare attorno a una funzione di ordine superiore con uno stato interno mutabile o, equivalentemente, un oggetto "fabbrica" che memorizzerà la risoluzione delle dipendenze. Questo è l'approccio che ho intenzione di suggerire qui. Userò la terminologia e l'API Autofac qui sotto, anche se l'idea dovrebbe essere facilmente adattabile ad altri framework di iniezione delle dipendenze.

class Lazy<T> where T : class {
    private T _cached = null;
    private IContainer _container;
    public Lazy(Func<IContainer> container) {
        _container = container();
    }
    public T Value {
        get {
            if(_cached != null) return _cached;
            _cached = _container.Resolve<T>();
            _container = null;
            return _cached;
        }
    }
}

Qui IContainer è inteso come contenitore di iniezione delle dipendenze e Resolve esegue la ricerca delle dipendenze. I consiglio vivamente di non passare il contenitore di dipendenze dell'iniezione agli oggetti, ma in questo caso sto visualizzando Lazy come parte del framework di iniezione delle dipendenze. In effetti, dovresti assicurarti che la tua infrastruttura per le dipendenze non fornisca già tale funzionalità. L'alternativa sarebbe quella di creare una fabbrica per ogni classe che si desidera iniettare pigramente. Il codice sarebbe fondamentalmente identico, ad eccezione del fatto che IContainer verrà sostituito da qualsiasi dipendenza e invece di utilizzare Resolve per creare l'oggetto che utilizzeresti new . In alternativa, puoi generalizzare Lazy per prendere un Action<T> e solo memorizzarlo e quindi questi oggetti di fabbrica sarebbero solo singoletti registrati nella radice di composizione come: container.Register(new Lazy<Foo>(() => new Foo())); La situazione ideale sarebbe register il tipo generico aperto Lazy<> , in modo che con una registrazione puoi gestire tutti i casi . (Ho verificato che puoi farlo funzionare con Autofac.)

Il risultato è che si dipenderà da Lazy<IFoo> anziché IFoo e si accederà tramite la proprietà Value (ma non nel costruttore!)