Question

我正在尝试编写一个像这样工作的日志类：

Log.Info("Something happened");  

Log.Error("Something else happened");

Log.Debug("Yet another thing happened!");

应该可以从命名空间的每个部分访问它并快速编写，所以我认为最好将其设置为静态。这样就可以避免为了记录消息而创建一个对象。

此时它有点像Console.WriteLine（）;

但是，我希望它能够有两种不同的模式：LogToConsole和LogToFile。

因此，以下语法最方便：

LogConsole.Info("This will display in the console");  

LogFile.Debug("This will be saved to a file");  

LogAll.Error("This will be saved to a file AND displayed in a console");

然而，我意识到可能会有大量的“模式”乘以非常大量的“logtypes”。

我怎样才能有效地做到这一点，我只需要编写一次每个logtype方法，并根据调用方法的派生类，动作发生或动作b发生？

理想情况下，我想一次定义所有方法，然后创建继承它们的类。但是，由于它们是静态方法，因此它们的行为始终是相同的。我无法告诉他们：“找出你的超类是什么，然后执行那个'SaveLog（）方法'。

我意识到使用抽象类会非常容易，但是我必须创建对象。

我有什么方法可以在C＃中做到这一点吗？

谢谢！

Answer 1

与Boo一样，也会推荐像log4net这样的记录器。

如果您确实想自己编写，我建议不要使用静态方法，因为它们会阻止您测试调用它的类/方法的能力。而是将ILogger接口注入可能需要记录的所有类。然后将“模式”与目标分开，这样就可以将一组目标注入记录器。

public interface ILogTarget
{
    void Save(string message);
}

public class LogToFile : ILogTarget
{
    public void Save(string message)
    {
        //
    }
}


public class LogToConsole : ILogTarget
{
    public void Save(string message)
    {
        //
    }
}

public interface ILogger
{
    void Debug(string message);
}

public class Logger : ILogger
{
    private readonly List<ILogTarget> _targets;
    private static Logger _logger;

    public Logger(List<ILogTarget> targets)
    {
        _targets = targets;
    }

    public void Debug(string message)
    {
        foreach (var target in _targets)
            target.Save($"Debug: {message}");
    }

}

public class TheClassThatMakesTheCall
{
    private readonly ILogger _logger;

    public TheClassThatMakesTheCall(ILogger logger)
    {
        _logger = logger;
    }

    public void AMethod()
    {
        _logger.Debug("some message");
    }
}

//In your IoC, register Logger as a type of ILogger, and pass in the targets that you want
//If your target vary per situation, you'll need a ILogTarget factory that returns a different list of loggers based on the situation

Answer 2

您不能从静态类继承。但是你可以让这些函数只是静态的。不要将类设为静态。只需将函数设置为静态，然后就可以在派生类中使用“new”关键字。它会是这样的

// IF this is your base class
public class Log
{
    public static bool Info(string Message)
    {
        Console.WriteLine(Message + " From Log");
        return true;
    }

    public static bool Success(string Message)
    {

        return true;
    }

    public static bool Error(string Message)
    {
        return true;
    }
}

//Then this can be your derived class
public class LogFile : Log
{
    public static new bool Info(string Message)
    {
        Console.WriteLine(Message + " From LogFile");
        return true;
    }

    public static new bool Success(string Message)
    {
        return true;
    }

    public static new bool Error(string Message)
    {
        return true;
    }
}

希望这有帮助。

继承调用其派生父方法的静态方法

2 个答案: