Is there a pattern for initializing objects created via a DI container

by

Any place where you need a run-time value to construct a particular dependency, Abstract Factory is the solution.

Having Initialize methods on the interfaces smells of a Leaky Abstraction.

In your case I would say that you should model the IMyIntf interface on how you need to use it – not how you intent to create implementations thereof. That’s an implementation detail.

Thus, the interface should simply be:

public interface IMyIntf
{
    string RunTimeParam { get; }
}

Now define the Abstract Factory:

public interface IMyIntfFactory
{
    IMyIntf Create(string runTimeParam);
}

You can now create a concrete implementation of IMyIntfFactory that creates concrete instances of IMyIntf like this one:

public class MyIntf : IMyIntf
{
    private readonly string runTimeParam;

    public MyIntf(string runTimeParam)
    {
        if(runTimeParam == null)
        {
            throw new ArgumentNullException("runTimeParam");
        }

        this.runTimeParam = runTimeParam;
    }

    public string RunTimeParam
    {
        get { return this.runTimeParam; }
    }
}

Notice how this allows us to protect the class’ invariants by use of the readonly keyword. No smelly Initialize methods are necessary.

An IMyIntfFactory implementation may be as simple as this:

public class MyIntfFactory : IMyIntfFactory
{
    public IMyIntf Create(string runTimeParam)
    {
        return new MyIntf(runTimeParam);
    }
}

In all your consumers where you need an IMyIntf instance, you simply take a dependency on IMyIntfFactory by requesting it through Constructor Injection.

Any DI Container worth its salt will be able to auto-wire an IMyIntfFactory instance for you if you register it correctly.

More Related Contents:

  1. Why not use an IoC container to resolve dependencies for entities/business objects?
  2. Why do I need an IoC container as opposed to straightforward DI code? [closed]
  3. Comparing Castle Windsor, Unity and StructureMap
  4. Ioc/DI – Why do I have to reference all layers/assemblies in application’s entry point?
  5. How to avoid Dependency Injection constructor madness?
  6. What is a composition root in the context of dependency injection?
  7. How do the major C# DI/IoC frameworks compare? [closed]
  8. Dependency Injection Unity – Conditional Resolving
  9. Inversion of Control vs Dependency Injection
  10. Inversion of Control < Dependency Injection [closed]
  11. Dependency injection through constructors or property setters?
  12. When to use PerThreadLifetimeManager?
  13. Is there a good/proper way of solving the dependency injection loop problem in the ASP.NET MVC ContactsManager tutorial?
  14. Which Dependency Injection Tool Should I Use? [closed]
  15. MEF (Managed Extensibility Framework) vs IoC/DI
  16. Dependency Injection vs Factory Pattern
  17. How do I effectively design my application where most classes depend on ILogger?
  18. How do you reconcile IDisposable and IoC?
  19. How to remove unit of work functionality from repositories using IOC
  20. Dependency Injection and IDisposable
  21. Enterprise Library Unity vs Other IoC Containers [closed]
  22. Understanding IoC Containers and Dependency Injection
  23. With Unity how do I inject a named dependency into a constructor?
  24. MEF vs. any IoC
  25. What is the purpose of the getter methods in Components in Dagger 2?
  26. Is it possible to bind different interfaces to the same instance of a class implementing all of them?
  27. Resolving HttpControllerContext with Castle Windsor
  28. How do I handle classes with static methods with Ninject?
  29. Windsor castle Injecting properties of constructed object
  30. Dependency Injection and the Strategy Pattern

Leave a Comment