Isn't it annoying to have to register all your repository implementations by hand?  When you get to a certain number of them, it becomes quite a task.  If you want to register them for multiple interfaces, it gets even worse.

When using Windsor as your inversion of control container, separating your repository registrations into a facility is a good start.  In general though, all our repositories follow a simple pattern and should be easily registerable automatically following an algorithm.

Domain driven design tells us that the repository interfaces are a part of the domain but the implementations are not.  Therefore, we usually have two assemblies that are important.

This is a typical project layout:

Our facility needs to allow us to configure what assemblies it searches for types and the base type of the repository. 


Here is a simple test describing the desired behavior:

    public class RepositoryRegistrationFacilityTestFixture
        public void ShouldRegisterCustomerRepository()
            var kernel = new Castle.MicroKernel.DefaultKernel();

            var facility = new RepositoryRegistrationFacility(typeof (IRepository<>), typeof (Customer).Assembly);

            new Castle.Core.Configuration.MutableConfiguration("facility-config"));

            kernel.Resolve<ICustomerRepository>().ShouldBeInstanceOfType(typeof (CustomerRepository));             kernel.Resolve<IRepository<Customer>>().ShouldBeInstanceOfType(typeof (CustomerRepository));

        protected interface IRepository<T>         {         }         protected interface ICustomerRepository : IRepository<Customer>         {            }         protected class CustomerRepository : ICustomerRepository         {         }         protected class Customer         {         }     }


    public class RepositoryRegistrationFacility : AbstractFacility
        private readonly Assembly[] assemblies;
        private readonly Type genericRepositoryType;

        public RepositoryRegistrationFacility(Type genericRepositoryType, params Assembly[] assemblies)
            this.assemblies = assemblies;
            this.genericRepositoryType = genericRepositoryType;

        protected override void Init()
            Predicate<Type> isGenericRepositoryInterface =
                type =>
                    x => x.IsGenericType && x.GetGenericTypeDefinition().IsAssignableFrom(genericRepositoryType));

            IEnumerable<Type> types =
                assemblies.Aggregate(Enumerable.Empty<Type>(), (accumulator, assembly) => accumulator.Concat(assembly.GetTypes()));

            IEnumerable<Type> repositoryInterfaces = types.Where(
                type => type.IsInterface && !type.IsGenericTypeDefinition && isGenericRepositoryInterface(type));

                .ForEach(interfaceType =>
                                 Type implementor =
                                     types.FirstOrDefault(type => interfaceType.IsAssignableFrom(type) && !type.IsAbstract);
                                 if (implementor == null) return;

                                 IEnumerable<Type> genericRepositoryInterfaceTypes = implementor.GetInterfaces().Where(
                                     x =>
                                     x.IsGenericType &&


Now in fluent configuration you can just do this:

container.AddFacility("persistent-repository-facility", new RepositoryRegistrationFacility(typeof(IRepository<>), typeof(IRepository<>).Assembly, typeof(SomethingRepository).Assembly));

I have not tested the binsor registration, but you should be able to do something like this to register it using binsor:

facility RepositoryRegistrationFacility:
    genericRepositoryType: IRepository
    assemblies: array(System.Reflection.Assembly, IRepository.Assembly, SomethingRepository.Assembly)

I hope this is useful.

kick it on