I found this code example explaining Open / Closed principle.
Code before application of principle:
public class Logger
{
public void Log(string message, LogType logType)
{
switch (logType)
{
case LogType.Console:
Console.WriteLine(message);
break;
case LogType.File:
// Code to send message to printer
break;
}
}
}
public enum LogType
{
Console,
File
}
And refactored code:
public class Logger
{
IMessageLogger _messageLogger;
public Logger(IMessageLogger messageLogger)
{
_messageLogger = messageLogger;
}
public void Log(string message)
{
_messageLogger.Log(message);
}
}
public interface IMessageLogger
{
void Log(string message);
}
public class ConsoleLogger : IMessageLogger
{
public void Log(string message)
{
Console.WriteLine(message);
}
}
public class PrinterLogger : IMessageLogger
{
public void Log(string message)
{
// Code to send message to printer
}
}
Can you explain me the reason to still keep Logger
class with private IMessageLogger
instance? I would simply avoid it by:
public interface ILogger
{
public void Log(string message);
}
public class ConsoleLogger : ILogger
{
public void Log(string message)
{
Console.WriteLine(message);
}
}
public class PrinterLogger : ILogger
{
public void Log(string message)
{
// Code to send message to printer
}
}
The only reason I can think about is, that in suggested solution with Logger
class, we could still refer to this class in client code, but we still need to modify all Log(msg)
calls to remove LogType
arguments.
Logger(IMessageLogger)
form would make sense iff theLogger
class contained some meaningful logic of its own other than blind passthroughs to theIMessageLogger
. For instance, aLogger
that prepends timestamps to every message or tries to prevent logging the same message too many times might be useful. But I've always been a bit fuzzy on how the O/C principle is supposed to work...// Some additional logic
comment insideLogger
class would make it more clear.LogType
parameter). In "after refactoring" this is reversed in that the the client is given a specific kind of logging. I think that this reversal makes for an odd example.