How to add a type forward to an existing Castle Windsor registration

I'm currently registering a bunch of stuff at one point in my initialisation sequence

Container.Register(AllTypes.FromAssemblyContaining<MyAssembly>()
    .BasedOn(typeof(IRepository<>))
    .WithService.Self().Configure(c => c.LifeStyle.Transient));

I'm using WithService.Self so that it doesn't automatically pick up AllInterfaces, so that the interface that I will want to add later on as a type forward has not already been added.

I'd like then (later on) to be able to add a type forward to one of the already registered components, and Intellisense on the ForwardedTypes property suggested using .Forward(typof()) e.g.

Container.Register(Component.For<IOtherInterface>()
    .Forward(typeof(IOtherInterface))
    .ImplementedBy<AlreadyRegisteredType>().LifeStyle.Transient);

Is this possible?

EDIT:

I've been trying to get the stuff that Krzysztof has suggested working so I've generated a test project (below). I've tried various combinations to get the ConfigureFor to forward IMyInterface to MySecondType, but just can't get it to work, when done as a second step after initial registration of my component types. I'm probably being dim, but I'm just not getting how the ConfigureFor command works, and the documentation is a little sketchy (non-existant) on the subject.

namespace TestProject1
{
    public class MyType : IMyInterface
    开发者_运维问答{
        public virtual string MyProperty { get; set; }
    }

    public class MySecondType : IMyInterface
    {
        public virtual string MySecondProperty { get; set; }
    }

    public interface IMyInterface
    {
    }

    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            //New Container
            var container = new WindsorContainer();

            //Register Types
            container.Register(
                AllTypes.FromAssemblyContaining<MyType>().BasedOn<IMyInterface>().WithService.Self().Configure(
                    c => c.LifeStyle.Transient));

            //Other stuff happens here...

            //Now Register our interface as a forward
            container.Register(AllTypes.FromAssemblyContaining<IMyInterface>()
                    .BasedOn<IMyInterface>()
                    .WithService.Base()
                    .ConfigureFor<IMyInterface>(r => r.Forward<MySecondType>()).Configure(c => c.LifeStyle.Transient));

            var typeA = new MySecondType();
            var typeB = container.Resolve<IMyInterface>();

            Assert.IsInstanceOfType(typeB.GetType(), typeA.GetType());

        }
    }
}

What you described in the comment is registering another component for the AlreadyRegisteredType.

If you want to add a forward to the same component use

ConfigureFor<AlreadyRegisteredType>(c => c.Forward<IOtherInterface>())

full example:

Container.Register(AllTypes.FromThisAssembly()
                    .BasedOn<IEmptyService>()
                    .WithService.Base()
                    .ConfigureFor<EmptyServiceComposite>(r => r.Forward<EmptyServiceComposite>()));

Once you registered some type

Container.Register(Component.For<SomeType>());

you can forward some interface to it in this way:

Container.Register(Component.For<ISomeInterface>()
    .UsingFactoryMethod<ISomeInterface>(kernel => kernel.Resolve<SomeType>()));