Question

In the Head First Design Patterns book, the author often says that one should program to interface rather than implementation?

What does that mean?

Answer 1

Let’s illustrate it with the following code:

namespace ExperimentConsoleApp
{
    class Program
    {
        static void Main()
        {
            ILogger loggerA = new DatabaseLogger();

            ILogger loggerB = new FileLogger();

            loggerA.Log("My message");
            loggerB.Log("My message");
        }
    }

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

    public class DatabaseLogger : ILogger
    {
        public void Log(string message)
        {
            // Log to database
        }
    }

    public class FileLogger : ILogger
    {
        public void Log(string message)
        {
            // Log to File
        }
    }

}

Suppose you are the Logger developer and the application developer needs a Logger from you. You give the Application developer your ILogger interface and you say to him he can use but he doesn’t have to worry about the implementation details.

After that you start developing a FileLogger and Databaselogger and you make sure they follow the interface that you gave to the Application developer.

The Application developer is now developing against an interface, not an implementation. He doesn’t know or care how the class is implemented. He only knows the interface. This promotes less coupling in code and it gives you the ability to (trough configuration files for example) easily switch to another implementation.