Dependency Injection - right place to inject

Looking at this answer on SO, I am a bit confused by the following "principle":

Apply the Hollywood Principle

The Hollywood Principle in DI terms says: Don't call the DI Container, it'll call you.

Never directly ask for a dependency by calling a container from within your code. Ask for it implicitly by using Constructor Injection.

But what if I have a repository class in my DAL, and I want to supply this instance to an object which is created when a TCP/IP client connects? At what place should I make the injection?

Right now, I have something like:

// gets created when a new TCP/IP client is connected
class Worker
{
    private readonly IClient client;
    public Worker(IClient client)
    {
        // get the repository
        var repo = IoC.GetInstance<IClientMessagesRepo>();

        // create an object which will parse messages
        var parser = new MessageParser(client);

        // create an object which will save them to repo
        var logger = new MessageLogger(parser, repo);
    }
}

I obviously cannot create this instance when my app is started. So where do I inject the repo?

Thanks a lot!

You should strive to only call IoC.GetInstance() once.

Since you cannot create the Worker at startup, you should instead create a WorkerFactory and have the DI container inject the dependency into that:

public class WorkerFactory
{
    private readonly IClientMessagesRepo clientMessagesRepo;
    public WorkerFactory(IClientMessagesRepo clientMessagesRepo)
    {
        this.clientMessagesRepo = clientMessagesRepo;
    }

    public Worker Create(IClient client)
    {
        return new Worker(client, clientMessagesRepo);
    }
}

Move IClientMessagesRepo to your constructor arguments:

public Worker(IClient client,IClientMessagesRepo clientMessagesRepo)

Now of course this only moves the problem a bit, to the point where the worker is created. Of course at some point calls into the IoC container are necessary. But in those cases I'd rather pass in the container in a parameter than access it from a static property. Or use some kind of factory.

Have IClientMessagesRepo in your arguments, and let the IoC fill that for you:

public Worker(IClient client, IClientMessagesRepo repo)    
{
    [...]
}

Obviously, your constructor should do a little more than just create a couple local variables, but you get the idea.

As I understand you have the repository in your IOC container, but not the IClient. Assuming that you have access to the IOC container at the time you create your worker class, and assuming that you are using StructureMap you can write:

IClient concreteClient = ...;
worker = container.Using<IClient>(concreteClient).GetInstance<Worker>();

That way you tell StructureMap to use a specific IClient instance, but obtain the other dependencies from the repository.

note: It is some time since I last used StructureMap, so perhaps the code is not 100% correct, but the concept is there, you can provide a concrete dependency when creating a component.