When registering types to the container Castle uses the type of the class in order to resolve. In the case that there is more than one registration for a specific type the Name property must be set:

public void Install(IWindsorContainer container, IConfigurationStore store)
{
    container.Register(
        Component.For<IFoo>().ImplementedBy<Foo>().Named("Registration1"),
        Component.For<IBar>().ImplementedBy<Bar().Named("Registration2"));
} 

A Lifestyle is the "how" Castle controls the scope in which a component is used and when to clean it up. The built-in lifestyles are Singelton, Transient, PerWebRequest, Scoped, Bound, PerThread and Pooled

container.Register(
   Component.For<IFoo>()
            .ImplementedBy<Foo>()
            .LifestyleSingleton(),

    Component.For<IBar>()
             .ImplementedBy<Bar>()
             .LifestyleTransient());

The entire idea with dependency injection is that a class does not instantiate its dependencies but requests them (through constructor or property). Using Castle the way for specifying the way to resolve a dependency is by using the DependsOn:

public class Foo : IFoo
{
    public Foo(IBar bar, string val)
    {
        Bar = bar;
        Val = val;
    }
    public IBar Bar { get; set; }
    public string Val { get; set; }
}

container.Register(
    Component.For<IBar>().ImplementedBy<Bar>().Named("bar1"),
    Component.For<IBar>().ImplementedBy<Bar>().Named("bar2"),

    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .DependsOn(Dependency.OnComponent("bar", "bar1"),
                        Dependency.OnValue("val","some value")));

When registering a component use the Interceptors() method to specify what are the interceptors/types of interceptors to be used for this component:

The TInterceptor must implement the IInterceptor interface

A single interceptor by type:

container.Register(
    Component.For<MyInterceptor>(),
    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .Interceptors<MyInterceptor>());

Two interceptors by type:

container.Register(
    Component.For<MyInterceptor1>(),
    Component.For<MyInterceptor2>(),
    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .Interceptors<MyInterceptor1, MyInterceptor2>());

More than 2 interceptors by type:

container.Register(
    Component.For<MyInterceptor1>(),
    Component.For<MyInterceptor2>(),
    Component.For<MyInterceptor3>(),
    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .Interceptors(typeof(MyInterceptor1), 
                           typeof(MyInterceptor2), 
                           typeof(MyInterceptor3)));