Question

I have a command class that needs to have 2 constructors. However,
using structuremap it seems that I can only specify one constructor to
be used. I have solved the problem for now by subtyping the specific
command class, which each implementation implementing it’s own
interface and constructor. Like the code below shows. The
ISelectCommand implements two separate interfaces for the
string constructor and the int constructor, just for the sake of
registering the two subtypes using structuremap.

However, I consider this a hack and I just wonder why is it not
possible for structuremap to resolve the constructor signature by the
type passed in as parameter for the constructor? Then I could register
the SelectProductCommand as an ISelectCommand and
instantiate it like:
ObjectFactury.With(10).Use>();
orObjectFactury.With(“testproduct”).Use>();

public class SelectProductCommand : ISelectCommand<IProduct>,
ICommand, IExecutable
{
   private readonly Func<Product, Boolean> _selector;
   private IEnumerable<IProduct> _resultList;

   public SelectProductCommand(Func<Product, Boolean> selector)
   {
       _selector = selector;
   }

   public IEnumerable<IProduct> Result
   {
       get { return _resultList; }
   }

   public void Execute(GenFormDataContext context)
   {
       _resultList = GetProductRepository().Fetch(context,
_selector);
   }

   private Repository<IProduct, Product> GetProductRepository()
   {
       return ObjectFactory.GetInstance<Repository<IProduct,
Product>>();
   }
}

public class SelectProductIntCommand: SelectProductCommand
{
    public SelectProductIntCommand(Int32 id): base(x =>
 x.ProductId == id) {}
}

public class SelectProductStringCommand: SelectProductCommand
{
    public SelectProductStringCommand(String name): base(x =>
x.ProductName.Contains(name)) {}
}

P.s. I know how to tell structuremap what constructor map to use, but my again my question is if there is a way to have structuremap select the right constructor based on the parameter passed to the constructor (i.e. using regular method overloading).

Answer 1

I think I solved the problem using a small utility class. This class gets the concrete type from ObjectFactory and uses this type to construct the instance according to the parameters past into the factory method. Now on the ‘client’ side I use ObjectFactory to create an instance of CommandFactory. The implementation of CommandFactory is in another solution and thus the ‘client solution’ remains independent of the ‘server’ solution.

public class CommandFactory
{

    public ICommand Create<T>()
    {
        return Create<T>(new object[] {});
    }

    public ICommand Create<T>(object arg1)
    {
        return Create<T>(new[] {arg1});
    }

    public ICommand Create<T>(object arg1, object arg2)
    {
        return Create<T>(new[] {arg1, arg2});
    }

    public ICommand Create<T>(object arg1, object arg2, object arg3)
    {
        return Create<T>(new[] {arg1, arg2, arg3});
    }

    public ICommand Create<T>(object[] arguments)
    {
        return (ICommand)Activator.CreateInstance(GetRegisteredType<T>(), arguments);
    }

    public static Type GetRegisteredType<T>()
    {
        return ObjectFactory.Model.DefaultTypeFor(typeof (T));
    }
}