What is it? I think the definition in your answer covers this question well. Although, I question why the definition includes that a component needs to explicitly define its dependencies. A canonical example of a component is an ActiveX control – do they need to explicitly define their dependencies? What problems does it solve? Management … Read more
In general, all components in an application should be composed as late as possible, because that ensures maximum modularity, and that modules are as loosely coupled as possible. In practice, this means that you should configure the container at the root of your application. In a desktop app, that would be in the Main method … Read more
After much pulling out of hair I discovered that the foreach loops were the culprits. What needs to happen is to call EF but return it into an IList<T> of that target type then loop on the IList<T>. Example: IList<Client> clientList = from a in _dbFeed.Client.Include(“Auto”) select a; foreach (RivWorks.Model.NegotiationAutos.Client client in clientList) { var … Read more
Having a switch case statement inside of a factory is a code smell. Interestingly, you don’t seem to be focusing on solving that issue at all. The best, most DI friendly solution for this scenario is the strategy pattern. It allows your DI container to inject the dependencies into the factory instances where they belong, … Read more
edit (not by the author): There is a comprehensive list of IoC frameworks available at https://github.com/quozd/awesome-dotnet/blob/master/README.md#ioc: Castle Windsor – Castle Windsor is best of breed, mature Inversion of Control container available for .NET and Silverlight Unity – Lightweight extensible dependency injection container with support for constructor, property, and method call injection Autofac – An addictive … Read more
Generally speaking, a DI Container should not be necessary for unit testing because unit testing is all about separating responsibilities. Consider a class that uses Constructor Injection public MyClass(IMyDependency dep) { } In your entire application, it may be that there’s a huge dependency graph hidden behind IMyDependency, but in a unit test, you flatten … Read more
The composition root is the single place in your application where the composition of the object graphs for your application take place, using the dependency injection container (although how this is done is irrelevant, it could be using a container or could be done manually using pure DI). There should only be one place where … Read more
Wow, can’t believe that Joel would favor this: var svc = new ShippingService(new ProductLocator(), new PricingService(), new InventoryService(), new TrackingRepository(new ConfigProvider()), new Logger(new EmailLogger(new ConfigProvider()))); over this: var svc = IoC.Resolve<IShippingService>(); Many folks don’t realize that your dependencies chain can become nested, and it quickly becomes unwieldy to wire them up manually. Even with factories, … Read more
The first question is the most difficult to answer. Is it bad practice to have Entities depend on outside classes? It’s certainly not the most common thing to do. If, for example, you inject a Repository into your Entities you effectively have an implementation of the Active Record pattern. Some people like this pattern for … Read more
You are right that if you use the container as a Service Locator, it’s more or less a glorified static factory. For lots of reasons I consider this an anti-pattern (also see this excerpt from my book). One of the wonderful benefits of Constructor Injection is that it makes violations of the Single Responsibility Principle … Read more