Castle Windsor Typed Factory Facility equivalents

Question

do any other .NET IoC containers provide equivalent functionality to the typed factory facility in Castle Windsor?

e.g. if I am using an abstract factory pattern in a WPF application:

public class MyViewModel
{
   private IAnotherViewModelFactory factory;

   public void ShowAnotherViewModel()
   {
      viewController.ShowView(factory.GetAnotherViewModel());
   }
}

I don't want to have to create a manual implementation of IAnotherViewModelFactory for every type of ViewModel I wish to show, I want the container to take care of this for me.

Montero

Seems like Ninject is about to - #8167196 – Trochlear

Answer 1

AutoFac has a feature called Delegate Factories, but as far as I can tell, it works only with delegates, and not interfaces.

I haven't encountered anything similar to Castle's Typed Factory Facility in neither StructureMap nor Unity, but that doesn't necessarily mean that they're not there...

---

The only way I can imagine that something like this could be implemented for interfaces is via a dynamic proxy. Since Castle Windsor has a Dynamic Proxy, but few other containers have anything similar, this might go a long way to explain why this feature isn't ubiquitous.

Unity also offers interception capabilities, so it must have some sort of dynamic proxy implementation, but I'm pretty sure it doesn't have anything equivalent to Typed Factories. Compared to other containers, Unity is rather basic.

Amenra

Thanks Mark, does that mean you would normally have a reference to the container in each factory class if you're not using Castle's Typed Factory Facility? – Montero

No, it means I'd just manually code them instead. If there are too many, then you could either use generics or some other form of code reuse. – Amenra

Answer 2

In Autofac you can implement typed factories on top of the delegate approach Mark mentions. E.g.

class AnotherViewModelFactory : IAnotherViewModelFactory {
    Func<AnotherViewModel> _factory;
    public AnotherViewModelFactory(Func<AnotherViewModel> factory) {
        _factory = factory;
    }
    public AnotherViewModel GetAnotherViewModel() {
        return _factory();
    }
}

If this class is registered with the container, along with AnotherViewModel Autofac will provide the Func<AnotherViewModel> implementation implicitly:

builder.RegisterType<AnotherViewModel>();
builder.RegisterType<AnotherViewModelFactory>()
    .As<IAnotherViewModelFactory>();

Practically any interface you can implement using Typed Factory Facility can be implemented in Autofac using this kind of approach. The primary difference is that the Windsor implementation configures the factory through the component registration API, while in Autofac the factory is a component in its own right.

For more sophisticated examples you might like to look at: http://code.google.com/p/autofac/wiki/RelationshipTypes and http://nblumhardt.com/2010/01/the-relationship-zoo/.

Joaquinajoash

+1, but doesn't shouldn't the implementation of GetAnotherViewModel be return _factory();? – Amenra

This technique works exactly the same way in Unity, by the way. – Insomnolence

Answer 3

I have recently implemented an equivalent of Castle Windsor Typed Factories for Unity. You can find the project at https://github.com/PombeirP/Unity.TypedFactories, and the NuGet package at http://nuget.org/packages/Unity.TypedFactories.

The usage is the following:

unityContainer
    .RegisterTypedFactory<IFooFactory>()
    .ForConcreteType<Foo>();

The parameter matching is done by name, which is fine for my needs, although the library could easily be extended to support other needs.

Welby