Am I missing something or is this a Service Locator anti-pattern? More about it here: http://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/

Service Locator is *really* an anti-pattern, but endovena (and also dejector) is a Dependency Injector (DI) framework, opposite of Service locator (http://www.infoq.com/articles/Succeeding-Dependency-Injection) DI is the solution to the principle of Inversion of Control (IoC), and DI Framework is a Framework (!) that help you to implement DI.

So, using Mark Seemann example:

```C#
public class OrderProcessor : IOrderProcessor
{
    public void Process(Order order)
    {
        var validator = Locator.Resolve<IOrderValidator>();
        if (validator.Validate(order))
        {
            var shipper = Locator.Resolve<IOrderShipper>();
            shipper.Ship(order);
        }
    }
}
```

Using DI you should write:

```D
class OrderProcessor : IOrderProcessor {
    private IOrderValidator validator;
    this(IOrderValidator validator, IOrderShipper shipper) {
      assert(validator !is null);
      this.validator = validator;
      this.shipper = shipper;
    }

    void Process(Order order) {
        if (validator.Validate(order))   {
            shipper.Ship(order);
        }
    }
}
```
in this version of OrderProcessor there is no Locator: the dependencies (IOrderValidator and IOrderShipper) are passed through constructor.

But... where is DI framework?


Endovena helps you to inject service into clients:

```D
import endovena;

void main() {
   Container container = new Container;
   container.register!(IOrderValidator,OrderValidator);
   container.register!(IOrderShipper,OrderShipper);
   container.register!(IOrderProcessor,OrderProcessor);

   auto processor = container.get!IOrderProcessor();

   processor.Process(order);
}

```


DI isn't easyto understand, but it's a very powerful pattern.

Some links:

* http://www.theserverside.com/news/1321158/A-beginners-guide-to-Dependency-Injection * http://geekswithblogs.net/chrisfalter/archive/2008/02/15/new-statement-considered-harmful.aspx * http://comoyo.github.io/blog/2013/02/06/the-inverse-of-ioc-is-control/ * http://www.loosecouplings.com/2011/01/dependency-injection-using-di-container.html

Reply via email to