Risoluzione delle dipendenze automatiche e manuali

Question

Ho un po 'di problemi nell'ordinare un modo per gestire le dipendenze automatiche risolte e manuali nelle mie classi.

Diciamo che ho due classi per calcolare i prezzi: uno calcola quanto addebiterò per la spedizione e l'altro quanto addebiterò per l'intero ordine. Il secondo utilizza il primo per sommare il prezzo di spedizione all'intero prezzo dell'ordine.

Entrambe le classi hanno una dipendenza da una terza classe che chiamerò ExchangeRate che mi dà il tasso di cambio che dovrei usare per il calcolo del prezzo.

Finora abbiamo questa catena di dipendenza:

OrderCalculator -> ShippingCalculator -> ExchangeRate

sto usando Ninject per risolvere queste dipendenze e questo stava lavorando fino ad ora. Ora ho il requisito che la velocità restituita dalla classe ExchangeRate varierà su un parametro che verrà fornito nel Costruttore (perché l'oggetto non funzionerà senza questo, quindi per rendere esplicita la dipendenza sul costruttore) in arrivo da un input dell'utente. Per questo motivo non posso più risolvere automaticamente le mie dipendenze.

Ogni volta che desidero OrderCalculator o qualsiasi altra classe che dipende da ExchangeRate, non posso chiedere al contenitore Ninject di risolverlo poiché è necessario fornire il parametro nel costruttore.

Che cosa suggerisci in questo caso?

Grazie!

EDIT: Aggiungiamo un certo codice

Questa catena di oggetti viene consumato da un servizio WCF e sto usando Ninject come contenitore DI.

 
public class OrderCalculator : IOrderCalculator 
{ 
     private IExchangeRate _exchangeRate; 
     public OrderCalculator(IExchangeRate exchangeRate) 
     { 
       _exchangeRate = exchangeRate; 
     } 
     public decimal CalculateOrderTotal(Order newOrder) 
     { 
       var total = 0m; 
       foreach(var item in newOrder.Items) 
       { 
         total += item.Price * _exchangeRate.GetRate(); 
       } 
       return total;    
     } 
} 

public class ExchangeRate : IExchangeRate 
{ 
     private RunTimeClass _runtimeValue; 
     public ExchangeRate(RunTimeClass runtimeValue) 
     { 
       _runtimeValue = runtimeValue; 
     } 
     public decimal GetRate() 
     { 
       //returns the rate according to _runtimeValue 
       if(_runtimeValue == 1) 
         return 15.3m; 
       else if(_runtimeValue == 2) 
         return 9.9m 
       else 
         return 30m; 
     } 
} 

//WCF Service 
public decimal GetTotalForOrder(Order newOrder, RunTimeClass runtimeValue) 
{ 
    //I would like to pass the runtimeValue when resolving the IOrderCalculator depedency using a dictionary or something 
    //Something like this ObjectFactory.Resolve(runtimeValue); 
    IOrderCalculator calculator = ObjectFactory.Resolve();  
    return calculator.CalculateOrderTotal(newOrder);  
} 

Answer 1

Ho finito per fare qualcosa di completamente diverso.

Prima di chiamare ObjectFactory per risolvere le dipendenze per me, creo una nuova istanza di IExchangeRate utilizzando runTimeValue e comunico al contenitore IoC/DI di utilizzarlo invece di crearne uno nuovo. In questo modo viene preservata l'intera catena di oggetti e non c'è bisogno di fabbriche.

//WCF Service 
public decimal GetTotalForOrder(Order newOrder, RunTimeClass runtimeValue) 
{ 
    IExchangeRate ex = new ExchangeRate(runtimeValue); 
    IOrderCalculator calculator = ObjectFactory.With<IExchangeRate>(ex).GetInstance(); 
    return calculator.CalculateOrderTotal(newOrder);  
} 

Ma poiché Ninject non hanno un modo per fare questo (solo associare nuovamente che non è quello che voglio) Ho cambiato il mio contenitore per StructureMap.

Grazie ragazzi per tutto il vostro aiuto! Lo apprezzo davvero!

Answer 2

Spostare l'inizializzazione fuori dal costruttore.

Answer 3

Come sempre, quando si ha una dipendenza parziale su un valore di runtime, the solution is an Abstract Factory.

Qualcosa del genere dovrebbe funzionare:

public interface IExchangeRateFactory 
{ 
    ExchangeRate GetExchangeRate(object runTimeValue); 
} 

punto, iniettare un IExchangeRateFactory nei vostri consumatori, invece di ExchangeRate e utilizzare il metodo GetExchangeRate per convertire il valore di run-time a un'istanza ExchangeRate.

Ovviamente sarà inoltre necessario fornire un'implementazione di IExchangeRateFactory e configurare NInject per mappare l'interfaccia alla propria implementazione.

Answer 4

Potrebbe essere utile iniettare factory delegates o providers. Entrambe sono praticamente una risposta di Mark (+ 1d).

Answer 5

aggiornata sulla base del codice:

//WCF Service 
public decimal GetTotalForOrder(Order newOrder, RunTimeClass runtimeValue) 
{ 
    //I would like to pass the runtimeValue when resolving the IOrderCalculator depedency using a dictionary or something 
    //Something like this ObjectFactory.Resolve(runtimeValue); 
    IOrderCalculator calculator = ObjectFactory.Resolve();  
    return calculator.CalculateOrderTotal(newOrder);  
} 

Avviso come questo metodo vuole solo runtimeValue in modo che possa passare a qualcos'altro? Questo sta accadendo perché la costruzione dell'oggetto e le responsabilità di runtime sono miste. Penso che dovresti chiedere un IOrderCalculator nel costruttore per questo metodo.

Quindi questo metodo diventa solo:

//WCF Service 
public decimal GetTotalForOrder(Order newOrder, IOrderCalculator calculator) 
{ 
    return calculator.CalculateOrderTotal(newOrder);  
} 

Ora, quando si costruisce la vostra IOrderCalculator si dovrebbe passare ad esso runtimeValue del costruttore. È un po 'difficile rispondere quando non sappiamo cosa sia runtimeValue o da dove provenga.