Here’s a habit that may help to reduce the complexity of your dependency injection tree. Ask yourself: how much of an injected dependency are you actually using?
The conversation goes like this…
I need to inject an
Great. Why? Because we need to read a cookie. So really….
Ah, OK I only need to inject an
Better! But seriously, are you only looking at cookies?
Right, I only ever touch
Request.Cookies, which is of type
Now we are getting somewhere! You only need an
HttpCookieCollection. That’s a pretty simple data type.
If that’s all you need, you don’t need to inject it at all — just pass it as an argument to the method that needs it.
Further, you likely don’t need to mock it (in the mocking-framework sense) for testing. Just
new one up and add some test values. Nice!
You could push it further and say, OK, which of CookieCollection’s methods am I actually using? Is there an smaller type that I could accept, maybe an
IEnumerable<HttpCookie>? How about just the
HttpCookie, no collection at all? A
The smaller the interface, the easier the mock — though there may be a trade-off in asking the caller to do more work.
Now: does your service have state, or more precisely, do its methods depend on the service’s state? If not, the method can — and likely should — be static. One less dependency on injection, one hopes.