Log4net and Unity Register

Question

I am trying to configure Unity to inject ILog into my classes, where the type / name in LogManager.CreateLogger () is set as the class into which ILog is injected.

Here is a similar question , but for the Structure Map

Answer 1

I know this answer is very late, but I recently had this problem.

Now there is the NuGet package, UnityLog4NetExtension , which registers the interface log4net.ILogand some Unity building strategies that allow you to simply insert the interface ILogand create Unity using the class into which it is introduced.

Code is also available through GitHub .

:

, ILOG-. .

//add the extension to the unity container 
container.AddNewExtension<Log4NetExtension>();

ILog,

public class MyClass
{ 
    private readonly ILog _logger;

    public MyClass(ILog loggerForMyClass)
    {
        _logger = loggerForMyClass;
    }
}

, _logger = LogManager.GetLogger(typeof(MyClass))

Answer 2

? , InjectionFactory Unity 2 ILog.

Answer 3

This is most likely not the best way, but it is the only way to find it. So now this is the best way :-)

Container.RegisterType<ILog>(new InjectionFactory(factory => new LoggerForInjection()));

-

public class LoggerForInjection : ILog
{
    private ILog _log;

    public bool IsDebugEnabled
    {
        get { return Log.IsDebugEnabled; }
    }

    public bool IsErrorEnabled
    {
        get { return Log.IsErrorEnabled; }
    }

    public bool IsFatalEnabled
    {
        get { return Log.IsFatalEnabled; }
    }

    public bool IsInfoEnabled
    {
        get { return Log.IsInfoEnabled; }
    }

    public bool IsWarnEnabled
    {
        get { return Log.IsWarnEnabled; }
    }

    public ILogger Logger
    {
        get { return _log.Logger; }
    }

    private ILog Log
    {
        get
        {
            if (_log == null)
            {
                // My tests shows, that is takes about 1 milli second to get the calling type
                var stackTrace = new StackTrace();
                string callingType = stackTrace.GetFrame(2).GetMethod().DeclaringType.FullName;

                _log = LogManager.GetLogger(callingType);
            }
            return _log;
        }
    }

    public void Debug(object message)
    {
        Log.Debug(message);
    }

    public void Debug(object message, Exception exception)
    {
        Log.Debug(message, exception);
    }

    public void DebugFormat(string format, params object[] args)
    {
        Log.DebugFormat(format, args);
    }

    public void DebugFormat(string format, object arg0)
    {
        Log.DebugFormat(format, arg0);
    }

    public void DebugFormat(string format, object arg0, object arg1)
    {
        Log.DebugFormat(format, arg0, arg1);
    }

    public void DebugFormat(string format, object arg0, object arg1, object arg2)
    {
        Log.DebugFormat(format, arg0, arg1, arg2);
    }

    public void DebugFormat(IFormatProvider provider, string format, params object[] args)
    {
        Log.DebugFormat(provider, format, args);
    }

    public void Error(object message)
    {
        Log.Error(message);
    }

    public void Error(object message, Exception exception)
    {
        Log.Error(message, exception);
    }

    public void ErrorFormat(string format, params object[] args)
    {
        Log.ErrorFormat(format, args);
    }

    public void ErrorFormat(string format, object arg0)
    {
        Log.ErrorFormat(format, arg0);
    }

    public void ErrorFormat(string format, object arg0, object arg1)
    {
        Log.ErrorFormat(format, arg0, arg1);
    }

    public void ErrorFormat(string format, object arg0, object arg1, object arg2)
    {
        Log.ErrorFormat(format, arg0, arg1, arg2);
    }

    public void ErrorFormat(IFormatProvider provider, string format, params object[] args)
    {
        Log.ErrorFormat(provider, format, args);
    }

    public void Fatal(object message)
    {
        Log.Fatal(message);
    }

    public void Fatal(object message, Exception exception)
    {
        Log.Fatal(message, exception);
    }

    public void FatalFormat(string format, params object[] args)
    {
        Log.FatalFormat(format, args);
    }

    public void FatalFormat(string format, object arg0)
    {
        Log.FatalFormat(format, arg0);
    }

    public void FatalFormat(string format, object arg0, object arg1)
    {
        Log.FatalFormat(format, arg0, arg1);
    }

    public void FatalFormat(string format, object arg0, object arg1, object arg2)
    {
        Log.FatalFormat(format, arg0, arg1, arg2);
    }

    public void FatalFormat(IFormatProvider provider, string format, params object[] args)
    {
        Log.FatalFormat(provider, format, args);
    }

    public void Info(object message)
    {
        Log.Info(message);
    }

    public void Info(object message, Exception exception)
    {
        Log.Info(message, exception);
    }

    public void InfoFormat(string format, params object[] args)
    {
        Log.InfoFormat(format, args);
    }

    public void InfoFormat(string format, object arg0)
    {
        Log.InfoFormat(format, arg0);
    }

    public void InfoFormat(string format, object arg0, object arg1)
    {
        Log.InfoFormat(format, arg0, arg1);
    }

    public void InfoFormat(string format, object arg0, object arg1, object arg2)
    {
        Log.InfoFormat(format, arg0, arg1, arg2);
    }

    public void InfoFormat(IFormatProvider provider, string format, params object[] args)
    {
        Log.InfoFormat(provider, format, args);
    }

    public void Warn(object message)
    {
        Log.Warn(message);
    }

    public void Warn(object message, Exception exception)
    {
        Log.Warn(message, exception);
    }

    public void WarnFormat(string format, params object[] args)
    {
        Log.WarnFormat(format, args);
    }

    public void WarnFormat(string format, object arg0)
    {
        Log.WarnFormat(format, arg0);
    }

    public void WarnFormat(string format, object arg0, object arg1)
    {
        Log.WarnFormat(format, arg0, arg1);
    }

    public void WarnFormat(string format, object arg0, object arg1, object arg2)
    {
        Log.WarnFormat(format, arg0, arg1, arg2);
    }

    public void WarnFormat(IFormatProvider provider, string format, params object[] args)
    {
        Log.WarnFormat(provider, format, args);
    }
}