protected override void Init()
{
    if (FacilityConfig == null) return;

// 第一步
    RegisterAspectEngine();
    // 第二步
    RegisterInterceptor();

// 第三步
    Kernel.ProxyFactory = new AopProxyFactory();

// 第四步
    _engine = (AspectEngine) Kernel[ typeof(AspectEngine) ];

// 第五步：向IOC里面加入任何组件的时候，OnComponentRegistered会回调
    Kernel.ComponentRegistered += new ComponentDataDelegate(OnComponentRegistered);
}

private void RegisterAspectEngine()
{
    // 获取当前facility的配置，相当于获取了a#的配置
    String contents = FacilityConfig.Value;

// 创建a#的builder
    AspectEngineBuilder builder = new AspectLanguageEngineBuilder(contents);

ComponentModel model = 
        new ComponentModel("aspectsharp.engine", 
            typeof(AspectEngine), typeof(AspectEngine));
    
    // a#的builder作为扩张属性
    model.ExtendedProperties.Add("builder", builder);
    // engine激活的时候执行AspectEngineActivator
    model.CustomComponentActivator = typeof(AspectEngineActivator);

// 把a# engine作为组件加入ioc中
    Kernel.AddCustomComponent( model );
}

private void RegisterInterceptor()
{
    // 讲AopInterceptor加入IOC中
    Kernel.AddComponent( "aspectsharp.interceptor", typeof(AopInterceptor) );
}

/// <summary>
/// Specialization of <see cref="Castle.Windsor.Proxy.DefaultProxyFactory"/>
/// that checks for aspects in the model and potential mixins.
/// </summary>
public class AopProxyFactory : DefaultProxyFactory
{
protected override void CustomizeContext(GeneratorContext context, IKernel kernel, 
    ComponentModel model, object[] arguments)
{
    // 获取a#的配置
    AspectDefinition aspect = (AspectDefinition) model.ExtendedProperties["aop.aspect"];

if (aspect == null) return;

// 得到所有mixin
    MixinDefinitionCollection mixins = aspect.Mixins;

foreach(MixinDefinition definition in mixins)
    {
        Type mixinType = definition.TypeReference.ResolvedType;
        
        try
        {
            // 创建一个minix对象并交给dynamicproxy，dynamicproxy产生proxy的时候会用到
            context.AddMixinInstance( Activator.CreateInstance( mixinType ) );
        }
        catch(Exception e)
        {
            throw new ApplicationException("Could not instantiate mixin " + mixinType.FullName, e);
        }
    }
}

protected override void CustomizeProxy(object proxy, GeneratorContext context, IKernel kernel, ComponentModel model)
{
    // 获取在上面的CustomizeContext函数中创建的mixin对象
    object[] mixins = context.MixinsAsArray();

// 所有实现了IProxyAware的mixin对象，都会把实际的代理set到里面交给客户处理
    //在“Castle实践8”中的SecurityMixin就是实现了IProxyAware的，在SecurityMixin类
    //上下文中可以任意使用proxy，这下明白了吧。
    for(int i=0; i < mixins.Length; i++)
    {
        object mixin = mixins[i];
        
        if (mixin is IProxyAware)
        {
            (mixin as IProxyAware).SetProxy(proxy);
        }
    }
}

protected override object InternalCreate()
{
    // 获取a#的builder
    AspectEngineBuilder builder = (AspectEngineBuilder) 
        base.Model.ExtendedProperties["builder"];

System.Diagnostics.Debug.Assert( builder != null );

// 创建engine
    return builder.Build();
}

private void OnComponentRegistered(String key, IHandler handler)
{
    // 检查a#配置中是否包含组件的“切面”
    //就是当前加入的这个组件是否需要aop（怎么说呢？？表达不太清晰，大家应该明白吧。请原谅~~）
    AspectDefinition[] aspects = 
        _engine.AspectMatcher.Match( handler.ComponentModel.Implementation, 
        _engine.Configuration.Aspects );

if (aspects.Length != 0)
    {
        // 如果组件需要aop，则合并配置中对此组件的切面定义
        //并将定义加入到组件的扩张属性中
        handler.ComponentModel.ExtendedProperties["aop.aspect"] = Union(aspects);

// 向组件加入拦截器
        //当向ioc请求组件对象的时候，拦截器的作用就是根据上面的定义来产生一个组件的proxy
        handler.ComponentModel.Interceptors.Add( 
            new InterceptorReference( typeof(AopInterceptor) ) );
    }
}

private AspectDefinition Union(AspectDefinition[] aspects)
{
    // 这里作用是合并对组件的“切面”配置内容
    //但作者todo了，未完成？

if (aspects.Length == 1)
    {
        return aspects[0];
    }

// TODO: Merge aspects

return aspects[0];
}

/// <summary>
/// Summary description for AopInterceptor.
/// </summary>
[Transient]
public class AopInterceptor : IMethodInterceptor, IOnBehalfAware
{
    private IKernel _kernel;
    private AspectEngine _engine;
    private IInvocationDispatcher _dispatcher;

public AopInterceptor(AspectEngine engine, IKernel kernel)
    {
        _engine = engine;
        _kernel = kernel;
    }

public void SetInterceptedComponentModel(ComponentModel target)
    {
        // 获取组件的aop配置
        AspectDefinition aspectDef = (AspectDefinition) 
            target.ExtendedProperties["aop.aspect"];

System.Diagnostics.Debug.Assert( aspectDef != null );

// InvocationDispatcher用于proxy的方法分派，ContainerInvocationDispatcher重写了
        //ObtainInterceptorInstance方法，唯一的作用是：尝试从IOC中获取拦截器对象
        _dispatcher = new ContainerInvocationDispatcher(aspectDef, _kernel);
        _dispatcher.Init(_engine);
    }

public object Intercept(IMethodInvocation invocation, params object[] args)
    {
        // a#内幕：_dispatcher.Intercept会处理客户的函数调用
        //Intercept方法会从ObtainInterceptorInstance获取拦截器实例
        //（ContainerInvocationDispatcher中重写的方法起作用了）
        // 如果没有拦截器则直接Proceed，有拦截器则在拦截器进行处理
        //这是a#拦截的一个简单过程，详细你可以参考：a#中的DefaultInvocationDispatcher源码
        return _dispatcher.Intercept( (IInvocation) invocation, args);
    }
}

/// <summary>
/// 获取拦截器对象
/// </summary>
protected override IMethodInterceptor ObtainInterceptorInstance(Type adviceType)
{
    if (_kernel.HasComponent( adviceType ))
    {
        // 方式一：从IOC中获取
        //如果我们把拦截器注册进IOC里面，这里就直接获取
        try
        {
            return (IMethodInterceptor) _kernel[adviceType];
        }
        catch(InvalidCastException ex)
        {
            // In this case, the specified interceptor
            // does not implement the IMethodInterceptor from
            // AopAlliance

String message = String.Format("The interceptor {0} does " + 
                "not implement AopAlliance.Interceptor.IMethodInterceptor", adviceType.FullName);

throw new ApplicationException(message, ex);
        }
    }

// 方式二：从A#的DefaultInvocationDispatcher中获取
    //A#中对拦截器对象实例是有缓存处理的（一个HashTable：_type2AdviceInstance）
    return base.ObtainInterceptorInstance(adviceType);
}

<configuration>
    <facilities>
        <facility id="aspectsharp">
<![CDATA[
import AopDemo.Interceptors
import AopDemo.Mixins

aspect log for [AopDemo]
    pointcut method(*)
        advice(LoggerInterceptor)
    end
end

aspect Security for [AopDemo]
    include SecurityMixin
    pointcut method(*)
        advice(SecurityCheckInterceptor)
    end
end
]]>
        </facility>
    </facilities>
</configuration>

container = new WindsorContainer(@"../../aspectsharp.ioc.xml");
container.AddFacility("aspectsharp", new AspectSharpFacility()) ;
container.AddComponent("persondao", typeof(PersonDao));

PersonDao dao = container["persondao"] as PersonDao;
dao.Create("AAA");
...