C＃：同名的普通和静态void

Question

I want to create a "log" class. There will be a global logger for the main things. but when the network part want log something to its own logger, it should be able to. My idea: a static logger instance in the logger class and a static void with the same name to log something. example:

Logger.log("ahaha");

will log something to the main logger and

new logger().log("kdsjfklsjd");

will log to a special logger. Here the code for my class:

public class Logger
{
    public static Logger GlobalLogger = new Logger();

    public Logger()
    {
    }

    public void log(string message)
    {
    }

    public static void log(string message)
    {
        Logger.GlobalLogger.log(message);
    }
}

I want tell the code that when i want to Logger.GlobalLogger.log(message) it should use the nonstatic void (with the same name)

Answer 1

You can't do it quite like that. You'll get the compiler error:

Type 'Logger' already defines a member called 'Log' with the same parameter types

You have two main options to resolve this:

1. Define static methods with different parameters:

    public class Logger { public void Log(string message) { ... } public static void Log(string message, int level) { ... } } 

2. Follow a 'singleton' pattern:

    public class Logger { public void Log(string message) { ... } private static Logger globalLogger; public static Logger GlobalLogger { get { if (globalLogger == null) { globalLogger = new Logger(); } return globalLogger; } } } 

Answer 2

One way to get around this compiler error is to add an interface:

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

public class Logger : ILogger {
    public static readonly ILogger GlobalLogger = new Logger();

    // explicit implementation allows the static and instance Log() to coexist peacefully
    void ILogger.Log(string message) { /* log */ }

    public static void Log(string message) { GlobalLogger.Log(message); }
}

One nice benefit of this pattern is that it is easy to provide many implementations of the ILogger interface. For example, you might even consider making the Logger class static (doesn't implement ILogger ) and making a separate GlobalLogger class:

public static class Logger {
    public static readonly ILogger Global = new GlobalLogger();

    public static void Log(string message) { Global.Log(message); }
}

public class GlobalLogger : ILogger {
    void Log(message) { /* log */ }
}