1

確かに他の人々はこれらの2つを一緒に働かせています。しかし、どういうわけか私はできません。私はCastleに比較的慣れていませんが、Castleを追加する方法についての説明に従いました。Castleはlog4net1.2.10で構築されたため、1.2.11で動作させるには、バインディングリダイレクトを追加する必要がありました。

私のコードでは、失敗はロガーインストーラーで発生します：

public class LoggerInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.AddFacility<LoggingFacility>(f => f.UseLog4Net());
    }
}

次の場合にMissingMethodExceptionが発生します。

void log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)

log4netが変更されたかどうかはわかりませんが、ConfigureAndWatchの署名は次のとおりです。

ICollection log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)

ですから、何が問題なのかはわかりますが、この問題については何も見つからないようで、私だけが問題にぶつかったとは思えません。

4

3 に答える 3

4

これは古い質問ですが、誰かが同じ問題に苦しんでいる場合に備えて、別の解決策を追加したかっただけです。バインディングリダイレクトを追加せず、log4netの2つのバージョンを参照せずに解決しました。

まず、次のパッケージを必ずアンインストールしてください（後者はlog4net 1.2.10に強く依存しており、最新のlog4netバージョンを使用します）。

Uninstall-Package Castle.Windsor-log4net
Uninstall-Package Castle.Core-log4net

LoggingFacilityとlog4netがインストールされていることを確認します（log4netバージョンを目的のバージョンに置き換えます）。

Install-Package Castle.LoggingFacility
Install-Package log4net -Version 1.2.13

AbstractLoggerFactoryを実装します。

public class Log4NetFactory : Castle.Core.Logging.AbstractLoggerFactory
{
    internal const string DefaultConfigFileName = "log4net.config";

    public Log4NetFactory()
        : this(DefaultConfigFileName)
    {
    }

    public Log4NetFactory(string configFile)
    {
        var file = GetConfigFile(configFile);
        XmlConfigurator.ConfigureAndWatch(file);
    }

    public Log4NetFactory(bool configuredExternally)
    {
        if (configuredExternally)
        {
            return;
        }

        var file = GetConfigFile(DefaultConfigFileName);
        XmlConfigurator.ConfigureAndWatch(file);
    }

    public Log4NetFactory(Stream config)
    {
        XmlConfigurator.Configure(config);
    }

    public override ILogger Create(Type type)
    {
        if (type == null)
            throw new ArgumentNullException("type");
        var log = LogManager.GetLogger(type);
        return new Log4netLogger(log, this);
    }

    public override ILogger Create(Type type, LoggerLevel level)
    {
        throw new NotSupportedException("Logger levels cannot be set at runtime. Please review your configuration file.");
    }

    public override ILogger Create(string name)
    {
        if (name == null)
            throw new ArgumentNullException("name");
        var log = LogManager.GetLogger(name);
        return new Log4netLogger(log, this);
    }

    public override ILogger Create(string name, LoggerLevel level)
    {
        throw new NotSupportedException("Logger levels cannot be set at runtime. Please review your configuration file.");
    }
}

ILoggerインターフェースを実装します。

[Serializable]
public class Log4netLogger : MarshalByRefObject, Castle.Core.Logging.ILogger
{
    private static readonly Type DeclaringType = typeof(Log4netLogger);

    public Log4netLogger(ILogger logger, Log4NetFactory factory)
    {
        Logger = logger;
        Factory = factory;
    }

    internal Log4netLogger()
    {
    }

    internal Log4netLogger(ILog log, Log4NetFactory factory)
        : this(log.Logger, factory)
    {
    }

    public bool IsDebugEnabled
    {
        get { return Logger.IsEnabledFor(Level.Debug); }
    }

    public bool IsErrorEnabled
    {
        get { return Logger.IsEnabledFor(Level.Error); }
    }

    public bool IsFatalEnabled
    {
        get { return Logger.IsEnabledFor(Level.Fatal); }
    }

    public bool IsInfoEnabled
    {
        get { return Logger.IsEnabledFor(Level.Info); }
    }

    public bool IsWarnEnabled
    {
        get { return Logger.IsEnabledFor(Level.Warn); }
    }

    protected internal Log4NetFactory Factory { get; set; }

    protected internal ILogger Logger { get; set; }

    public override string ToString()
    {
        return Logger.ToString();
    }

    public virtual Castle.Core.Logging.ILogger CreateChildLogger(string name)
    {
        return Factory.Create(Logger.Name + "." + name);
    }

    public void Debug(string message)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, message, null);
        }
    }

    public void Debug(Func<string> messageFactory)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, messageFactory.Invoke(), null);
        }
    }

    public void Debug(string message, Exception exception)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, message, exception);
        }
    }

    public void DebugFormat(string format, params Object[] args)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
        }
    }

    public void DebugFormat(Exception exception, string format, params Object[] args)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
        }
    }

    public void DebugFormat(IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(formatProvider, format, args), null);
        }
    }

    public void DebugFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsDebugEnabled)
        {
            Logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(formatProvider, format, args), exception);
        }
    }

    public void Error(string message)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, message, null);
        }
    }

    public void Error(Func<string> messageFactory)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, messageFactory.Invoke(), null);
        }
    }

    public void Error(string message, Exception exception)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, message, exception);
        }
    }

    public void ErrorFormat(string format, params Object[] args)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
        }
    }

    public void ErrorFormat(Exception exception, string format, params Object[] args)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
        }
    }

    public void ErrorFormat(IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, new SystemStringFormat(formatProvider, format, args), null);
        }
    }

    public void ErrorFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsErrorEnabled)
        {
            Logger.Log(DeclaringType, Level.Error, new SystemStringFormat(formatProvider, format, args), exception);
        }
    }

    public void Fatal(string message)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, message, null);
        }
    }

    public void Fatal(Func<string> messageFactory)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, messageFactory.Invoke(), null);
        }
    }

    public void Fatal(string message, Exception exception)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, message, exception);
        }
    }

    public void FatalFormat(string format, params Object[] args)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
        }
    }

    public void FatalFormat(Exception exception, string format, params Object[] args)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
        }
    }

    public void FatalFormat(IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(formatProvider, format, args), null);
        }
    }

    public void FatalFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsFatalEnabled)
        {
            Logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(formatProvider, format, args), exception);
        }
    }

    public void Info(string message)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, message, null);
        }
    }

    public void Info(Func<string> messageFactory)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, messageFactory.Invoke(), null);
        }
    }

    public void Info(string message, Exception exception)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, message, exception);
        }
    }

    public void InfoFormat(string format, params Object[] args)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
        }
    }

    public void InfoFormat(Exception exception, string format, params Object[] args)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
        }
    }

    public void InfoFormat(IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, new SystemStringFormat(formatProvider, format, args), null);
        }
    }

    public void InfoFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsInfoEnabled)
        {
            Logger.Log(DeclaringType, Level.Info, new SystemStringFormat(formatProvider, format, args), exception);
        }
    }

    public void Warn(string message)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, message, null);
        }
    }

    public void Warn(Func<string> messageFactory)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, messageFactory.Invoke(), null);
        }
    }

    public void Warn(string message, Exception exception)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, message, exception);
        }
    }

    public void WarnFormat(string format, params Object[] args)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
        }
    }

    public void WarnFormat(Exception exception, string format, params Object[] args)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
        }
    }

    public void WarnFormat(IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(formatProvider, format, args), null);
        }
    }

    public void WarnFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
    {
        if (IsWarnEnabled)
        {
            Logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(formatProvider, format, args), exception);
        }
    }
}

WindsorInstallerにカスタムLog4NetFactoryを登録します。

public class LoggerInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.AddFacility<LoggingFacility>(x =>
            x.WithConfig(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile)
            .ToLog("MyLogger")
            .LogUsing<Log4NetFactory>());
    }
}

通常のlog4net構成をapp/web.configに追加します（まだ存在しない場合）。

「MyLogger」がlog4net構成に存在することを確認してください。

<logger name="MyLogger" additivity="false">
  <level value="DEBUG" />
  <appender-ref ref="MyAppender" />
</logger>

これで、次のようにILoggerを注入できます。

public class MyClass
{
    public MyClass(ILogger logger)
    {
        logger.Info("Castle Windsor with newest log4net.");
    }
}

上記の方法を使用すると、CastleWindsorと一緒に任意のバージョンのlog4netを使用できます。私はlog4net1.2.13をCastleWindsor3.3.3で動作させています。

于 2015-06-24T07:16:28.950 に答える
2

log4netの両方のバージョンを使用するようにアプリケーションを構成する必要がありました。

<configuration>
  <runtime>
     <assemblyBinding>
      <dependentAssembly>
        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" />
        <codeBase version="1.2.11.0" href="..\packages\log4net.2.0.0\lib\net40-full\log4net.dll" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="log4net" publicKeyToken="1b44e1d426115821" />
        <codeBase version="1.2.10.0" href="..\packages\log4net.1.2.10\lib\2.0\log4net.dll" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

それを機能させるためのより良い方法があるかどうかはわかりませんが、これは機能します。

于 2012-10-17T06:54:13.753 に答える
1

Log4Netは、マイナーリリースの公開鍵トークンを変更します。これは煩わしく、多くの人々の悲しみを引き起こしている可能性があります。構成を確認し、次の質問と回答を読んでください

publickeytokenを変更し続けるlog4netを回避するにはどうすればよいですか？

これはあなたの問題ではないか、唯一の問題かもしれませんが、castleとlog4netのアップグレードで同様の問題が発生したとき、これが私の大きな悲しみでした。

于 2012-10-16T21:27:55.853 に答える