/// <summary>
/// Log功能的interface
/// </summary>
public interface ILog
{
    /// <summary>
    /// Traces 訊息
    /// </summary>
    /// <param name="message">訊息</param>
    void Trace(string message);

    /// <summary>
    /// Traces 把某個物件內容dump出來
    /// </summary>
    /// <param name="outputObject">要dump的物件</param>
    void Trace(object outputObject);

    /// <summary>
    /// Traces 訊息加上format的參數
    /// </summary>
    /// <param name="message">訊息</param>
    /// <param name="args">format的參數</param>
    void Trace(string message, params object[] args);

    /// <summary>
    /// Traces 把某個物件內容dump出來，並且在dump內容加上一段訊息
    /// </summary>
    /// <param name="message">加上的訊息</param>
    /// <param name="outputObject">要dump的物件</param>
    void Trace(string message, object outputObject);

// 。。。。 其他log層級的方法定義

/// <summary>
/// 使用Nlog作為ILog的實作
/// </summary>
public class NlogLogger : ILog
{
    // NLog 物件
    private Logger logger;

    /// <summary>
    /// Initializes a new instance of the <see cref="NlogLogger"/> class.
    /// </summary>
    public NlogLogger()
    {
        logger = NLog.LogManager.GetCurrentClassLogger();
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="NlogLogger"/> class.
    /// </summary>
    /// <param name="name">目前要使用Log的Class名字</param>
    public NlogLogger(string name)
    {
        logger = NLog.LogManager.GetLogger(name);
    }
	
// ..其他實作

// 還是在NlogLogger.cs 裡面

/// <summary>
/// Traces 訊息
/// </summary>
/// <param name="message">訊息</param>
public void Trace(string message)
{
    if (logger.IsTraceEnabled)
    {
        logger.Trace(message);
    }
}

  /// <summary>
/// Traces 訊息加上format的參數
/// </summary>
/// <param name="message">訊息</param>
/// <param name="args">format的參數</param>
public void Trace(string message, params object[] args)
{
    Trace(string.Format(message, args));
}

  /// <summary>
/// Traces 把某個物件內容dump出來
/// </summary>
/// <param name="outputObject">要dump的物件</param>
public void Trace(object outputObject)
{
    Trace(JsonConvert.SerializeObject(outputObject, Formatting.Indented));
}

/// <summary>
/// Traces 把某個物件內容dump出來，並且在dump內容加上一段訊息
/// </summary>
/// <param name="message">加上的訊息</param>
/// <param name="outputObject">要dump的物件</param>
public void Trace(string message, object outputObject)
{
    Trace(message + Environment.NewLine +
	 	JsonConvert.SerializeObject(outputObject, Formatting.Indented));
}

// ..其他層級實作如上

// NLogModule.cs
 
/// <summary>
/// Dependency Injection Module 用來註冊ILog將會使用NLog
/// </summary>
public class NLogModule : Autofac.Module
{
	/// <summary>
    /// Override to add registrations to the container.
    /// </summary>
    /// <param name="builder">The builder through which components can be
    /// registered.</param>
    /// <remarks>
    /// Note that the ContainerBuilder parameter is unique to this module.
    /// </remarks>
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<NlogLogger>()
          .As<ILog>();
    }

    /// <summary>
    /// 增加透過用Constructor或者Property的方式注入
    ///		<see cref="MvcInfrastructure.Common.Log.NlogLogger"/>
    ///		為<see cref="MvcInfrastructure.Common.Log.ILog"/>的實作
    /// </summary>
    /// <param name="componentRegistry">The component registry.</param>
    /// <param name="registration">The registration to attach functionality to.</param>
    /// <remarks>
    /// This method will be called for all existing <i>and future</i> component
    /// registrations - ordering is not important.
    /// </remarks>
    protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, 
			IComponentRegistration registration)
    {
        // Handle constructor parameters. 處理Constructor注入
        registration.Preparing += OnComponentPreparing;
        
        // Handle properties. 處理Property注入
        registration.Activated += (sender, e) => 
			InjectLoggerProperties(e.Instance);
    }
}

//NLogModule.cs

// ....
/// <summary>
/// Called when [component preparing]. 用來增加Constructor方式注入
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PreparingEventArgs"/> instance containing the event data.</param>
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
    var t = e.Component.Activator.LimitType;
    e.Parameters = e.Parameters.Union(
        new[]
        {
            new ResolvedParameter((p, i) => p.ParameterType == typeof(ILog),
                (p, i) => i.Resolve<ILog>(new NamedParameter("name", t.FullName)))
        });
}

// .....

//NLogModule.cs

// ....

/// <summary>
/// Property注入的邏輯
/// </summary>
/// <param name="instance">目前被實例化的Class Instance</param>
private static void InjectLoggerProperties(object instance)
{
    var instanceType = instance.GetType();

    // Get all the injectable properties to set.
    // If you wanted to ensure the properties were only UNSET properties,
    // here's where you'd do it.
    var properties = instanceType
      .GetProperties(BindingFlags.Public | BindingFlags.Instance)
      .Where(p => p.PropertyType == typeof(ILog) && p.CanWrite && p.GetIndexParameters().Length == 0);

    // Set the properties located.
    foreach (var propToSet in properties)
    {
        propToSet.SetValue(instance, new NlogLogger(instanceType.FullName), null);
    }
}

// .....

//Global.asax

// ....

Builder.RegisterModule<NLogModule>();

// .....