Question

I am trying to configure an application such that types from assemblyA can be used by my console to allow for logging in an AOP style. The JournalInterceptor will just write out method calls, input and maybe output arguments to a log file or datastore of some kind.

I can register one type at a time but I would like to register all types in one go. Once I get going I may add some filtering to the registered types but I am missing something.

I am trying to use Classes.FromAssemblyContaining but am not sure how to get at an IRegistration instance for the call to WindsorContainer::Register

Any clues?

// otherAssembly.cs
namespace assemblyA
{
  public class Foo1 { public virtual void What(){} }
  public class Foo2 { public virtual void Where(){} }
}
// program.cs
namespace console
{
  using assemblyA;

  public class JournalInterceptor : IInterceptor {}

  public class Program
  {
     public static void Main()
     {
        var container = new Castle.Windsor.WindsorContainer()
            .Register(
                Component.For<JournalInterceptor>().LifeStyle.Transient,
                // works but can't be the best way
                Component.For<Foo1>().LifeStyle.Transient
                    .Interceptors<JournalInterceptor>(),
                Component.For<Foo2>().LifeStyle.Transient,
                    .Interceptors<JournalInterceptor>(),
                // how do I do it this way
                Classes.FromAssemblyContaining<Foo1>()
                        .Pick()
                        .LifestyleTransient()
                        .Interceptors<JournalInterceptor>()
                      );

        Foo1 foo = container.Resolve<Foo1>();
     }
  }
}

Answer 1

Implement a Pointcut. In Castle Windsor this is done by implementing the IModelInterceptorsSelector interface.

It would go something like this:

public class JournalPointcut : IModelInterceptorsSelector
{
    public bool HasInterceptors(ComponentModel model)
    {
        return true; // intercept everything - probably not a good idea, though
    }

    public InterceptorReference[] SelectInterceptors(
        ComponentModel model, InterceptorReference[] interceptors)
    {
        return new[] 
        {
            InterceptorReference.ForType<JournalInterceptor>()
        }.Concat(interceptors).ToArray();
    }
}

Then register the Interceptor and the Pointcut with the container:

this.container.Register(Component.For<JounalInterceptor>());

this.container.Kernel.ProxyFactory.AddInterceptorSelector(new JournalPointcut());

For in-depth explanation, you may want to see this recording.