Question

I have a search form that can search in different provider.
I started out by having a base controller

public SearchController : Controller
{

    protected readonly ISearchService _searchService

    public SearchController(ISearchService searchService)
    {
        _searchService= searchService;
    }

    public ActionResult Search(...)
    {
        // Use searchService to query and return a view.
    }

}

And child controllers

TwitterController : SearchController
{
    ...
}

NewsController : SearchController
{
    ...
}

I use StructureMap to insert all my dependencies in the controller. With this setup, I was able to change the SearchService depending on the type of the controller being instanciated.

x.For<ISearchService>().ConditionallyUse(o =>
      {
            o.TheDefault.Is.OfConcreteType<NewsSearchService>();

            o.If(c => c.ParentType == typeof(TwitterController))
             .ThenIt.Is.OfConcreteType<TwitterSearchService>();

             ...

      });

That even allowed me to set different Views for each controller, (just putting the corresponding folder (Twitter, News…) and the Parent controller is still handling all the Search, with a simple

return View(results) 

which is displaying the correct view specific to twitter, news, or other

Now that was cool and looked great, I a single form and the different views are displayed in tabs on the same page. That’s where it starts to get complicated with this approach. The form has to post to /Twitter to search in twitter, to /News to search in news… which means I should change the action parameter of the form depending on which tab I am and display the correct tab on when the form returns depending on.. the url? craziness follows.

If you have built something like this already or know what’s the best approach to this, please advices are welcome.

Now I think I would have less pain using a parameter in the form and posting to a single controller. I am thinking of injecting the correct SearchService depending on this parameter. What would be the best approach? I thought of using a model binder,

So I would have my ActionMethod that look like this:

public ActionResult Search(ISearchService service, Query query)
{
    var results = service.Find(query);
}

But I think would need to make a call like this in the ModelBinder

ObjectFactory.GetInstance(...);

Based on the querystring parameter that describe which provider to use, and that doesn’t seem more elegant to me. I feel stuck, help :(.

Answer 1

I was trying to figure out how to use the abstract factory pattern and still let structuremap resolve all the dependencies of my components.

I believe that is the way I am going to implement it, but I submit this here to get some feedback if someone would read this.

As explain in the previous answer, I do not want to build the whole object graph depending on which provider I need in the Abstract factory.

ie :

class StatServiceFactory : IStatServiceFactory
{
    public IStatService Create(string provider)
    {
        switch(provider)
        {
            case "blog":
                return new  StatService(IFacetRepository,ISearchManager,IConfigManager,BooleanQueryBuilder);
                       //How to resolve the Config, the SearchManager, and BooleanQueryBuilder?   
                       //Add more abstract factories? It starts to get messy in my opinion...
         }
    }

}

What I can do is have the abstract factory use my container to create an instance of my search managers depending on a parameter (coming from the querystring in my case)

Structuremap allows to create named instances this way :

x.For<ISearchManager>().Use<AbcSearchManager>().Named("Abc");
x.For<ISearchManager>().Use<DefSearchManager>().Named("Def");

I need a way to inject the container in my Abstract factory.
I would probably wrap the container in a wrapper defined like this. That would keep me from leaking Structuremap into my project. I dont need more that those 2 features within the abstract factory anyway, but it is not necessary:

public interface IContainerWrapper
{
    object GetInstance<T>();
    object GetNamedInstance<T>(string key);
}

and the implementation :

public class ContainerImpl : IContainerWrapper
{
     private readonly Container _container
     public ContainerImpl(Container container)
     {
          _container = container;
     }

     ...
}

And setup StructureMap to resolve dependencies to my abstract factory like that :

x.For<IContainer>.Use(new ContainerImpl(this));
x.For<IFactory>.Use<Factory>()

My factory would be then much simpler and would create my instance like that :

public class SearchmanagerFactory
{
    private readonly IContainerWrapper _container;

    public SearchmanagerFactory(IContainerProvider containerProvider)
    {
        _container = containerProvider;
    }

    public ISearchManager Create(string provider)
    {
       //eed to handle the bad input for provider.
        return (ISearchManager)
            _container.Resolve<ISearchManager>(provider);
    }
}

That seems pretty clean this way :).
Thoughts?