Orchard学习 01、orchard日志

一、日志模块类图

1、ILogger接口及实现

2、ILoggerFactory接口及实现

3、其他

二、NullLogger类型

    NullLogger类型是实现ILogger接口的空类型。它的 IsEnabled 方法总是返回false；Log 方法是个空实现。在代码中要用到日志的地方设计1个 NullLogger属性 作为占位符，在代码运行时将这个对象替换为真正的日志对象。如果不替换，则代码也能编译成功，运行时也不会出错。

 publicclassNullLogger:ILogger
 {
 privatestaticreadonlyILogger _instance =newNullLogger();
 publicstaticILoggerInstance
 {
  get
 {
 return _instance;
 }
 }
 #region ILogger 成员

 public bool IsEnabled(LogLevel level)
 {
 returnfalse;
 }

 publicvoidLog(LogLevel level,Exception exception,string format,paramsobject[] args)
 {

 }

 #endregion
 }

三、和autofac的结合使用

    在orchard中，autofac的使用无处不在。日志模块也不例外。前面说过，NullLogger 类型相当于1个日志类型的占位符，在运行时可以被替换为真实的日志类型。那在运行时如何替换呢？这就要和autofac结合在一起使用

1、LoggingModule类

    LoggingModule类继承了Module类型。Module类型是autofac的类型。

 publicclassLoggingModule:Module
 {
 privatereadonlyConcurrentDictionary<string,ILogger> _loggerCache;

 publicLoggingModule()
 {
  _loggerCache =newConcurrentDictionary<string,ILogger>();
 }

 protectedoverridevoidLoad(ContainerBuilder moduleBuilder)
 {
 // by default, use Orchard's logger that delegates to Castle's logger factory
  moduleBuilder.RegisterType<CastleLoggerFactory>().As<ILoggerFactory>().InstancePerLifetimeScope();
  moduleBuilder.RegisterType<OrchardLog4netFactory>().As<Castle.Core.Logging.ILoggerFactory>().InstancePerLifetimeScope().WithParameter(newNamedParameter("isFullTrust",false));

 // call CreateLogger in response to the request for an ILogger implementation
  moduleBuilder.Register(CreateLogger).As<ILogger>().InstancePerDependency();
 }

 protectedoverridevoidAttachToComponentRegistration(IComponentRegistry componentRegistry,IComponentRegistration registration)
 {
 var implementationType = registration.Activator.LimitType;

 // build an array of actions on this type to assign loggers to member properties
 var injectors =BuildLoggerInjectors(implementationType).ToArray();

 // if there are no logger properties, there's no reason to hook the activated event
 if(!injectors.Any())
 return;

 // otherwise, whan an instance of this component is activated, inject the loggers on the instance
  registration.Activated+=(s, e)=>
 {
 foreach(var injector in injectors)
  injector(e.Context, e.Instance);
 };
 }

 privateIEnumerable<Action<IComponentContext,object>>BuildLoggerInjectors(Type componentType)
 {
 // Look for settable properties of type "ILogger"
 var loggerProperties = componentType
 .GetProperties(BindingFlags.SetProperty|BindingFlags.Public|BindingFlags.Instance)
 .Select(p =>new
 {
 PropertyInfo= p,
  p.PropertyType,
 IndexParameters= p.GetIndexParameters(),
 Accessors= p.GetAccessors(false)
 })
 .Where(x => x.PropertyType==typeof(ILogger))// must be a logger
 .Where(x => x.IndexParameters.Count()==)// must not be an indexer
 .Where(x => x.Accessors.Length!=|| x.Accessors[].ReturnType==typeof(void));//must have get/set, or only set

 // Return an array of actions that resolve a logger and assign the property
 foreach(var entry in loggerProperties)
 {
 var propertyInfo = entry.PropertyInfo;
  yield return(ctx, instance)=>
 {
 string component = componentType.ToString();
 if(component != instance.GetType().ToString())
 {
 return;
 }
 var logger = _loggerCache.GetOrAdd(component, key => ctx.Resolve<ILogger>(newTypedParameter(typeof(Type), componentType)));
  propertyInfo.SetValue(instance, logger,null);
 };
 }
 }

 privatestaticILoggerCreateLogger(IComponentContext context,IEnumerable<Parameter> parameters)
 {
 // return an ILogger in response to Resolve<ILogger>(componentTypeParameter)
 var loggerFactory = context.Resolve<ILoggerFactory>();
 var containingType = parameters.TypedAs<Type>();
 return loggerFactory.CreateLogger(containingType);
 }
 }

    

1)   Load方法在 builder.Build()时会被调用，这里注册了 3个类型

moduleBuilder.RegisterType<CastleLoggerFactory>().As<ILoggerFactory>().InstancePerLifetimeScope();

 

moduleBuilder.RegisterType<OrchardLog4netFactory>().As<Castle.Core.Logging.ILoggerFactory>().InstancePerLifetimeScope().WithParameter(new NamedParameter("isFullTrust", false));

      

moduleBuilder.Register(CreateLogger).As<ILogger>().InstancePerDependency();

 

2) AttachToComponentRegistration方法也会在 builder.Build()时会被调用，它会调用BuildLoggerInjectors 方法。而 BuildLoggerInjectors方法会检查 类型 中的属性，如果属性是 ILogger接口，则会被替换为 CastleLogger或 OrchardLog4netLogger类。当然你也能注册为自定义的其他日志类型。

 

四、log4net 设置

    orchard使用log4net作为日志的具体实现。配置如下

 <?xml version="1.0" encoding="utf-8"?>
 <log4net>
 <root>

 <priority value="ERROR"/>
 <appender-refref="error-file"/>
 </root>

 <logger name="NHibernate.Cache">
 <priority value="ERROR"/>
 </logger>

 <logger name="NHibernate.AdoNet.AbstractBatcher">
 <priority value="ERROR"/>
 </logger>

 <logger name="NHibernate.Util.ADOExceptionReporter">
 <priority value="ERROR"/>
 </logger>

 <appender name="error-file" type="Orchard.Logging.OrchardFileAppender">
 <file value="orchard-error"/>
 <appendToFile value="true"/>
 <immediateFlush value="false"/>
 <staticLogFileName value="false"/>
 <rollingStyle value="Date"/>
 <datepattern value="-yyyy.MM.dd'.log'"/>
 <lockingModel type="log4net.Appender.FileAppender+MinimalLock"/>
 <layout type="log4net.Layout.PatternLayout">
 <conversionPattern value="%date [%thread] %logger - %P{Tenant} - %message%newline %P{Url}%newline"/>
 </layout>
 </appender>
 </log4net>

 

 

五、orchard日志模块使用示例

1、要使用日志的类型

1.  /// <summary>
    /// 要使用日志的类型
    /// </summary>
    publicclassThing
    {
    publicThing()
    {
    Logger=NullLogger.Instance;
    }
    /// <summary>
    /// 设置类型为 ILogger 的属性
    /// </summary>
    publicILoggerLogger
    {
     get;
    set;
    }
    publicvoidTestMethod()
    {
    //这使用Log方法则 Logger属性 会被设置为 CastleLogger类；使用Error方法 Logger属性 会被设置为OrchardLog4netLogger类
    Logger.Log(Orchard.Logging.LogLevel.Error,newException("测试异常"),"测试异常使用CastleLogger类型");
    Logger.Error(newException("测试异常"),"测试异常使用OrchardLog4netLogger类型");
    }
    }

2、调用

1.  publicvoidCreateTest()
    {
    var builder =newContainerBuilder();//构建autofac容器
    builder.RegisterModule(newLoggingModule());//注册LoggingModule
     builder.RegisterType<Thing>();//注册 Thing类型
    var container = builder.Build();//Build 容器
    var thing = container.Resolve<Thing>();//从容器中解析 Thing类型
    thing.TestMethod();//调用TestMethod方法，则会调用日志
    }

 

 

    

 

 

 

来自为知笔记(Wiz)