CastleOpenClosed

using System;
using System.Reflection;
using Castle.Facilities.TypedFactory;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using NUnit.Framework;

namespace TestConsole.Castle
{
    [TestFixture]
    public class TestCastleStuff : IExecutable
    {
        [Test]
        public void Execute()
        {
            using (var container = new WindsorContainer())
            {
                container.AddFacility<TypedFactoryFacility>();
                container.Register(
                    Component.For<ProcessorSelector, ITypedFactoryComponentSelector>(),
                    Classes.FromThisAssembly()
                        .BasedOn(typeof(IProcessor<,>))
                        .WithServiceBase()
                        .LifestyleTransient(),
                    

                    Component.For<IProcessorFactory>()
                        .AsFactory(f => f.SelectedWith<ProcessorSelector>())
                        .LifeStyle.Transient
                    );

                var factory = container.Resolve<IProcessorFactory>();

                var processors = factory.GetAllProcessorsForMessage(new MessageImpl(), new MessageOriginImp());
                
                Assert.That(processors, Is.Not.Empty);
                foreach (var processor in processors)
                {
                    Console.WriteLine(processor.Process());
                }
            }
        }
    }

    public interface IProcessor
    {
        string Process();
    }

    public interface IProcessor<TMessage, TMessageOrigin> : IProcessor
        where TMessage : Message
        where TMessageOrigin : IMessageOrigin
    {
        TMessage Message { get; set; }

        string Process(Message message);
    }

    public class ProcessorImp<TMessageOrigin> : IProcessor<Message, TMessageOrigin>
        where TMessageOrigin : IMessageOrigin
    {
        private readonly IMapper<TMessageOrigin> _mapper;

        public ProcessorImp(IMapper<TMessageOrigin> mapper)
        {
            _mapper = mapper;
        }

        public string Process()
        {
            return Process(Message);
        }

        public Message Message { get; set; }
        public string Process(Message message)
        {
            _mapper.Map(message);
        }
    }

    public interface IMessageOrigin{ }

    public class Message {}

    public class MessageImpl : Message{}

    public class MessageOriginImp : IMessageOrigin{}

    public interface IMapper<TMessageOrigin> where TMessageOrigin : IMessageOrigin
    {
        string Map(Message message);
    }

    public class MapperImpl : IMapper<MessageOriginImp>
    {
        public string Map(Message message)
        {
            return message.GetType() + " for MessageOriginImpl";
        }
    }

    public interface IProcessorFactory
    {
        IProcessor[] GetAllProcessorsForMessage(Message message, IMessageOrigin origin);
    }

    public class ProcessorSelector : DefaultTypedFactoryComponentSelector
    {
        /// <summary>
        /// Selects type of the component to resolve. Uses <paramref name="method"/> return type.
        /// </summary>
        /// <param name="method"/><param name="arguments"/>
        /// <returns/>
        protected override Type GetComponentType(MethodInfo method, object[] arguments)
        {
            return typeof(IProcessor<,>).MakeGenericType(arguments[0].GetType(), arguments[1].GetType()).MakeArrayType();
        }
    }
}