dependency injection - What are good ways to reduce the number of dependencies? -

i using dependency injection quite time , technique, have problem of many dependencies should injected 4 - 5 seems much.

but cannot find way make simpler. instance have class business logic sends messages, accepts 2 other business logic dependencies needed (one translate data messages sent, , 1 translate messages received).

but apart needs "technical" dependencies ilogger, itimerfactory (because needs create timers inside), ikeygenerator (to generate unique keys).

so whole list grows pretty big. there common ways reduce number of dependencies?

one way handle refactor towards aggregates (or facades). mark seemann wrote article on it, check out (actually highly recommend his book well, saying). have following (as taken article):

public orderprocessor(iordervalidator validator,                       iordershipper shipper,                       iaccountsreceivable receivable,                       irateexchange exchange,                       iusercontext usercontext) 

you can refactor to:

public orderprocessor(iordervalidator validator,                       iordershipper shipper,                       iordercollector collector) 

where ordercollector facade (it wraps previous 3 dependencies):

public ordercollector(iaccountsreceivable receivable,                       irateexchange exchange,                       iusercontext usercontext) 

i hope helps.

edit

in terms of cross-cutting concerns (logging , caching example) , strategy handle them, here suggestion (that's do), have following:

public interface iorderservice {     void doawesome(); }  public class orderservice : iorderservice {     public void doawesome()     {         // thing here ... no logging no nothing     } } 

here i'd use decorator pattern create orderservice has logging enabled:

public class orderservicewithlogging : iorderservice {     private readonly iorderservice _orderservice;     private readonly ilogger _logger;      public orderservicewithlogging(iorderservice orderservice, ilogger logger)     {         _orderservice = orderservice;         _logger = logger;     }      public void doawesome()     {         _orderservice.doawesome();         _logger.log("awesome done!");     } } 

it might bit of overhead imho, it's clean , testable.

another way go aspect oriented programming , concepts such interception, intercept method calls , perform tasks result. many di frameworks (i wanna all?) support interception, might prefer.