Are primitive constructor parameters a bad idea when using an IoC Container? [closed]

Answer 1

Well I ended up redesigning this after reading the book Dependency Injection in .Net (I highly recommend this book to any object-oriented developer, not just .Net developers and not just those interested in using an IoC container!).

I've now got the following in a Domain assembly:

public interface IImageFileService
{
    void RenameFiles();
    void CopyFiles(); 
}

public interface IImageLinkMapRepository
{
    IList<ImageLink> GetImageLinks(); 
}

Then in a FileAccess assembly I've created implementations for these interfaces:

public class ImageFileService : IImageFileService
{
    public ImageFileService(IImageLinkMapRepository repository)
    {
        // null checks etc. left out for brevity
        _repository = repository;
    }

    public void RenameFiles()
    {
        // rename files, using _repository.GetImageLinks(), which encapsulates
        // enough information for it to do the rename operations without this
        // class needing to know the specific details of the source/dest dirs.
    }

    public void CopyFiles() 
    { 
        // same deal as above
    }
}

So essentially, I've removed the need for primitive types in my constructor, at least for this class. At some point I did need that information, but that was injected into the ImageLinkMapRepository where the information made more sense. I used autofac named parameters to handle injecting them.

So I guess to answer my own question, primitive constructor parameters are a good idea if they make sense, but make sure you put them where they belong. If things don't seem to be jiving properly, it can probably be improved by rethinking the design.

Answer 2

In your example what you are actually passing are dependencies, but moreover data needed by the class to operate.

In your case it sounds like the methods RenameFiles() and CopyFiles() operate on the parameters that are passed to them. Given their names I would think that the methods on a single instance of ImageFileGenerator can be called with different parameters. If that is true arguably the parameters should be on the method calls themselves not the constructor.

If, on the other hand, on one instance RenameFiles() and CopyFiles() are each only called once with the same parameters the parameters would be good candidates for the constructor.

I personally would try to avoid property injection for required dependencies - in that case constructor injection is much more appropriate.