C# 如何正确地将拦截器添加到不使用'；t没有类型为ILogger的字段或属性

基本上，我正在尝试为每个没有ILogger属性或字段的类添加一个日志拦截器

我正在处理的项目是使用Monorail 2.1和最新的Castle Windsor稳定版（2012年8月，3.1.0）构建的

假设我有：

[ViewComponentDetails("Followers")]
    public class FollowersComponent : ViewComponent
    {
        private readonly ISession NHibernateSession;

        public FollowersComponent(ISession session)
        {
            NHibernateSession = session;
        }

        public override void Render()
        {
            IPrincipal loggedUser = EngineContext.CurrentUser;
            if ((loggedUser.Identity.AuthenticationType == "Monorail Type") && (loggedUser.Identity.IsAuthenticated))
            {
                var user = (PrincipalAdapter<Int64>)Session["User"];
                PropertyBag["loggedUser"] = NHibernateSession.Get<User>(user.UserId);
                RenderView("Followers");

            }
        }
    }

---

尝试将您的设施更改为：

public class ExtendedLoggingFacility : LoggingFacility
{
    public ExtendedLoggingFacility()
        : base()
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi) :
        base(loggingApi)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string configFile) :
        base(loggingApi, configFile)
    {
    }

    public ExtendedLoggingFacility(string customLoggerFactory, string configFile) :
        base(customLoggerFactory, configFile)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string customLoggerFactory, string configFile) :
        base(loggingApi, customLoggerFactory, configFile)
    {
    }

    protected override void Init()
    {
        base.Init();
        Kernel.Register(Component.For<AspectLogger>());
        Kernel.ComponentModelCreated += Kernel_ComponentModelCreated;
    }

    private void Kernel_ComponentModelCreated(ComponentModel model)
    {
        if (
            !(model.Implementation.GetProperties()
                     .Any(prop => prop.PropertyType.GetInterfaces().Contains(typeof(ILogger))) ||
              model.Implementation.GetFields()
                     .Any(l => l.FieldType.GetInterfaces().Contains(typeof(ILogger)))))
        {
            model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType<AspectLogger>());
        }
    }
}

公共类ExtendedLoggingFacility:LoggingFacility
{
公共扩展日志设施（）
：base（）
{
}
公共扩展日志设施（LoggerLoggingAPI）：
基地（loggingApi）
{
}
公共扩展LoggingFacility（LoggerImplementation loggingApi，字符串配置文件）：
基本（loggingApi、configFile）
{
}
公共ExtendedLoggingFacility（字符串customLoggerFactory，字符串configFile）：
基本（customLoggerFactory，配置文件）
{
}
公共扩展LoggingFacility（LoggerImplementation loggingApi、字符串customLoggerFactory、字符串configFile）：
基本（loggingApi、customLoggerFactory、configFile）
{
}
受保护的重写void Init（）
{
base.Init（）；
Register（Component.For

它看起来是这样的：

public class ExtendedLoggingFacility : LoggingFacility
{
    public ExtendedLoggingFacility()
        : base()
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi) :
        base(loggingApi)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string configFile) :
        base(loggingApi, configFile)
    {
    }

    public ExtendedLoggingFacility(string customLoggerFactory, string configFile) :
        base(customLoggerFactory, configFile)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string customLoggerFactory, string configFile) :
        base(loggingApi, customLoggerFactory, configFile)
    {
    }

    protected override void Init()
    {
        base.Init();
        Kernel.Register(Component.For<AspectLogger>());
        Kernel.ComponentModelBuilder.AddContributor(new AddLoggingAspect());
    }
}

public class AddLoggingAspect : IContributeComponentModelConstruction
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (
            !(model.Implementation.GetProperties()
                   .Any(prop => prop.PropertyType.GetInterfaces().Contains(typeof(ILogger))) ||
              model.Implementation.GetFields()
                   .Any(l => l.FieldType.GetInterfaces().Contains(typeof(ILogger)))))
        {
            model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType<AspectLogger>());
        }
    }
}

公共类ExtendedLoggingFacility:LoggingFacility
{
公共扩展日志设施（）
：base（）
{
}
公共扩展日志设施（LoggerLoggingAPI）：
基地（loggingApi）
{
}
公共扩展LoggingFacility（LoggerImplementation loggingApi，字符串配置文件）：
基本（loggingApi、configFile）
{
}
公共ExtendedLoggingFacility（字符串customLoggerFactory，字符串configFile）：
基本（customLoggerFactory，配置文件）
{
}
公共扩展LoggingFacility（LoggerImplementation loggingApi、字符串customLoggerFactory、字符串configFile）：
基本（loggingApi、customLoggerFactory、configFile）
{
}
受保护的重写void Init（）
{
base.Init（）；
Kernel.Register（Component.For（））；
AddContributor（新的AddLoggingAspect（））；
}
}
公共类AddLoggingAspect:IContributeComponentModelConstruction
{
公共void进程模型（IKernel内核、组件模型）
{
如果(
！（model.Implementation.GetProperties（）
.Any（prop=>prop.PropertyType.GetInterfaces（）.Contains（typeof（ILogger）））||
model.Implementation.GetFields（）
.Any（l=>l.FieldType.GetInterfaces（）.Contains（typeof（ILogger '）））
{
model.Interceptors.AddIfNotInCollection（InterceptorReference.ForType（））；
}
}
}

[TestFixture]
    public class ControllersInstallerTests
    {
        private IWindsorContainer containerWithControllers;

        [SetUp]
        public void OnSetup()
        {
            containerWithControllers = new WindsorContainer()
                        .Install(FromAssembly.Containing(typeof(UserController)));
        }

 [Test]
        public void All_components_which_dont_have_ILogger_as_a_property_or_field_have_an_AspectLog()
        {
            var allComponents = GetPublicClassesFromApplicationAssembly(p => !(p.GetProperties().Any(prop => prop.PropertyType.IsAssignableFrom(typeof(ILogger)) || p.GetFields().Any(g => g.FieldType.IsAssignableFrom(typeof(ILogger))))));
            var allHandlers = GetAllHandlers(containerWithControllers);
            foreach (var comp in allComponents)
            {
                var handlersForComponent = GetHandlersFor(comp, containerWithControllers);
                if (handlersForComponent.Length != 0)
                    Assert.True(handlersForComponent.All(p => p.ComponentModel.HasInterceptors));
            }
        }

public class ExtendedLoggingFacility : LoggingFacility
{
    public ExtendedLoggingFacility()
        : base()
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi) :
        base(loggingApi)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string configFile) :
        base(loggingApi, configFile)
    {
    }

    public ExtendedLoggingFacility(string customLoggerFactory, string configFile) :
        base(customLoggerFactory, configFile)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string customLoggerFactory, string configFile) :
        base(loggingApi, customLoggerFactory, configFile)
    {
    }

    protected override void Init()
    {
        base.Init();
        Kernel.Register(Component.For<AspectLogger>());
        Kernel.ComponentModelCreated += Kernel_ComponentModelCreated;
    }

    private void Kernel_ComponentModelCreated(ComponentModel model)
    {
        if (
            !(model.Implementation.GetProperties()
                     .Any(prop => prop.PropertyType.GetInterfaces().Contains(typeof(ILogger))) ||
              model.Implementation.GetFields()
                     .Any(l => l.FieldType.GetInterfaces().Contains(typeof(ILogger)))))
        {
            model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType<AspectLogger>());
        }
    }
}

public class ExtendedLoggingFacility : LoggingFacility
{
    public ExtendedLoggingFacility()
        : base()
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi) :
        base(loggingApi)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string configFile) :
        base(loggingApi, configFile)
    {
    }

    public ExtendedLoggingFacility(string customLoggerFactory, string configFile) :
        base(customLoggerFactory, configFile)
    {
    }

    public ExtendedLoggingFacility(LoggerImplementation loggingApi, string customLoggerFactory, string configFile) :
        base(loggingApi, customLoggerFactory, configFile)
    {
    }

    protected override void Init()
    {
        base.Init();
        Kernel.Register(Component.For<AspectLogger>());
        Kernel.ComponentModelBuilder.AddContributor(new AddLoggingAspect());
    }
}

public class AddLoggingAspect : IContributeComponentModelConstruction
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (
            !(model.Implementation.GetProperties()
                   .Any(prop => prop.PropertyType.GetInterfaces().Contains(typeof(ILogger))) ||
              model.Implementation.GetFields()
                   .Any(l => l.FieldType.GetInterfaces().Contains(typeof(ILogger)))))
        {
            model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType<AspectLogger>());
        }
    }
}