C# 包装器类太多 class LogUtil:ILogUtility { log4net.ILog日志； 公共LogUtil（） { log=log4net.LogManager.GetLogger（typeof（T）.FullName）； } 公共无效日志（日志类型、日志类型、字符串消息） { WriteLine（“来自类{0}-message{1}的日志记录，typeof（T）.FullName，message）； } } 公共类记录器 { 我的直觉(logutility);； 公共记录器（ILogUtility） { _logutility=logutility； } 公共无效日志（日志类型、日志类型、字符串消息） { _logutility.Log（日志类型，消息）； } }

我需要具有灵活的功能，并且能够在将来删除LogUtil类并使用其他东西

因此，我编写了LoggerUtility包装类，如下所示：

class LogUtil<T> : ILogUtility
{
    log4net.ILog log;

    public LogUtil()
    {
        log = log4net.LogManager.GetLogger(typeof(T).FullName);
    }

    public void Log(LogType logtype, string message)
    {
        Console.WriteLine("logging coming from class {0} - message {1} " , typeof(T).FullName, message);
    }
}

public class Logger
{
    ILogUtility _logutility;

    public Logger(ILogUtility logutility)
    {
        _logutility = logutility;
    }


    public void Log(LogType logtype, string message)
    {
        _logutility.Log(logtype, message);
    }


}

class LoggerUtility<T>
{

    Logger logger;
    public LoggerUtility()
    {
        LogUtil<T> logutil = new LogUtil<T>();

        logger = new Logger(logutil);

    }

    public void Log(LogType logtype, string message)
    {
        logger.Log(logtype, message);
    }

}

public class TestCode
{
    public void test()
    {

        new LoggerUtility<TestCode>().Log(LogType.Info, "hello world");

    }

}

类日志实用程序
{
记录器；
公用事业（）
{
LogUtil LogUtil=新的LogUtil（）；
记录器=新记录器（logutil）；
}
公共无效日志（日志类型、日志类型、字符串消息）
{
logger.Log（日志类型，消息）；
}
}

我的客户代码如下：

class LogUtil<T> : ILogUtility
{
    log4net.ILog log;

    public LogUtil()
    {
        log = log4net.LogManager.GetLogger(typeof(T).FullName);
    }

    public void Log(LogType logtype, string message)
    {
        Console.WriteLine("logging coming from class {0} - message {1} " , typeof(T).FullName, message);
    }
}

public class Logger
{
    ILogUtility _logutility;

    public Logger(ILogUtility logutility)
    {
        _logutility = logutility;
    }


    public void Log(LogType logtype, string message)
    {
        _logutility.Log(logtype, message);
    }


}

class LoggerUtility<T>
{

    Logger logger;
    public LoggerUtility()
    {
        LogUtil<T> logutil = new LogUtil<T>();

        logger = new Logger(logutil);

    }

    public void Log(LogType logtype, string message)
    {
        logger.Log(logtype, message);
    }

}

public class TestCode
{
    public void test()
    {

        new LoggerUtility<TestCode>().Log(LogType.Info, "hello world");

    }

}

公共类测试代码
{
公开无效测试（）
{
新的LoggerUtility（）.Log（LogType.Info，“hello world”）；
}
}

为了从LogUtil获得松散耦合，我最终编写了两个包装器类Logger和LoggerUtility。所以在将来，如果我必须添加另一种方法 在ILogUtility中，我必须将该方法添加到Logger类，然后添加到LoggerUtility

编写LoggerUtility的最佳方法是什么，这样我就可以按如下方式编写客户端代码：

class LogUtil<T> : ILogUtility
{
    log4net.ILog log;

    public LogUtil()
    {
        log = log4net.LogManager.GetLogger(typeof(T).FullName);
    }

    public void Log(LogType logtype, string message)
    {
        Console.WriteLine("logging coming from class {0} - message {1} " , typeof(T).FullName, message);
    }
}

public class Logger
{
    ILogUtility _logutility;

    public Logger(ILogUtility logutility)
    {
        _logutility = logutility;
    }


    public void Log(LogType logtype, string message)
    {
        _logutility.Log(logtype, message);
    }


}

class LoggerUtility<T>
{

    Logger logger;
    public LoggerUtility()
    {
        LogUtil<T> logutil = new LogUtil<T>();

        logger = new Logger(logutil);

    }

    public void Log(LogType logtype, string message)
    {
        logger.Log(logtype, message);
    }

}

public class TestCode
{
    public void test()
    {

        new LoggerUtility<TestCode>().Log(LogType.Info, "hello world");

    }

}

newloggerutility（）.Log（LogType.Info，“hello world”）；

请让我知道

---

谢谢你，你不需要第二个包装器，你需要一个工厂或者使用依赖注入框架来围绕log4net构建一个合适的包装器

使用Ninject并修改界面，您可以

new LoggerUtility<TestCode>().Log(LogType.Info, "hello world");

kernel.Bind（typeof（ILogUtility））.To（typeof（Log4NetUtil）；

并将其实例化为

kernel.Bind(typeof(ILogUtility<>)).To(typeof(Log4NetUtil<>);

var logger=kernel.Get（）；

其中，记录器接口/类为：

var logger = kernel.Get<ILogUtility<MyClass>>();

公共接口的可扩展性，其中T:class
{
无效日志（日志类型、日志类型、字符串消息）；
}
公共类Log4NetUtil:ILogUtility其中T:class
{
log4net.ILog日志；
公共LogUtil（）
{
log=log4net.LogManager.GetLogger（typeof（T）.FullName）；
}
公共无效日志（日志类型、日志类型、字符串消息）
{
WriteLine（“来自类{0}-message{1}的日志记录，typeof（T）.FullName，message）；
}
}

看起来您正在添加一个不需要的抽象级别

如果我们从您的最终结果开始，LoggerUtility只需要有一个接口，它可以根据

LogType

参数来记录事情

您当前编写的

Logger

类只不过是

ilogutability

接口的一个薄薄的包装。那么为什么要添加该层呢？为什么

Logger

类不能直接使用

ilogutability

实例呢？您甚至可以更进一步，将您的接口定义为

ilogutability

要知道，当您创建一个

LoggerUtility

时，它将使用的记录器实例将基于Foo类

---

但老实说，我认为您可能只是在这里重新发明轮子。看看。它可能会减轻您的努力，并从长远来看更有意义。

您真正改变日志基础结构的频率有多高？这似乎不太常见。但我仍然希望flexibility@dotnet-医生：那不是你的错ally是有道理的。你是说设置DI框架的代码会写入记录器吗？在这种情况下，特定的代码段可以直接创建实例。在所有其他情况下，你应该注入记录器。@dotnet Practicer-我已经用Ninject的示例更新了。