C# Dependency Injection – Per-Method-Call Instantiation Without IoC Container

I read with interest this article which states:

A DI Container should only be referenced from the Composition Root. All other modules should have no reference to the container.

This means that all the application code relies solely on Constructor Injection (or other injection patterns), but is never composed. Only at the entry point of the application is the entire object graph finally composed.

I take it to mean all instances should be injected, never instantiated by anything other than the IoC container.

Under this pattern, this is not allowed:

class MyClass {
    void SomeMethod() {
        var w = new Worker();
        w.DoSomething();
    }
}

Instead it should look more like this:

class MyClass {
    protected readonly IWorker _worker;
    public MyClass(IWorker worker) {
        _worker = worker;
    }
    void SomeMethod() {
        _worker.DoSomething();
    }
}

This works fine if I only need one instance of Worker per instance of MyClass. But what if Worker is stateful (or worse, Disposable) and I need a new instance each time SomeMethod is called?

I could do something like this:

class MyClass {
    protected readonly IUnityContainer _container;
    public MyClass(IUnityContainer container) {
        _container = container;
    }
    void SomeMethod() {
        using (var w = _container.Resolve<IWorker>()) {
            w.DoSomething();
        }
    }
}

But that technique is frowned upon by this article, and also it violates the principle that the container should only be referenced from the composition root.

I could inject a factory:

class MyClass {
    protected readonly IWorkerFactory _factory;
    public MyClass(IWorkerFactor factory) {
        _factory = factory;
    }
    void SomeMethod() {
        using (var w = _factory.Create<IWorker>()) {
            w.DoSomething();
        }
    }
}

…which seems to address the issue. But then when I go to write the factory, I have to reference the container again:

class WorkerFactory : IWorkerFactory
{
    protected readonly IUnityContainer _container;

    public WorkerFactory(IUnityContainer container) {
        _container = container;
    }

    public T Create<T>() where T : IWorker {
        return _container.Resolve<T>();
    }
}

…so really, it seems, I have moved the problem, not solved it.

If it is true that "A DI Container should only be referenced from the Composition Root," I don't see how that is possible for per-method-call instantiation.

How do I support per-method-call instantiation without referencing the container from outside the composition root?