The simplest example I can think of to illustrate this question involves two logger classes.

In this example, LoggerA and LoggerB both implement an ILogger interface to achieve polymorphism.

```
public interface ILogger
{
    void SomeMethodBNeeds;
    void LogB;
    bool LogA;
}

public class LoggerA : ILogger
{
    public void SomeMethodBNeeds()
    {
        // Do nothing; un-needed here.
    }

    public bool LogA()
    {
        // Perform some work.
    }

    public void LogB()
    {
        LogA();
    }
}

public class LoggerB : ILogger
{
    public void SomeMethodBNeeds()
    {
        // Perform some work.
    }

    public bool LogA()
    {
        LogB();
        return true;
    }

    public void LogB()
    {
        // Perform some work.
    }
}

```

Since ILogger is an interface, both LoggerA and LoggerB need to implement every method, even if LoggerA does not need `SomeMethodBNeeds`. As such `SomeMethodBNeeds` is empty and does nothing in LoggerA.

The same applies to the LogA and LogB methods; they are different, but both needed and used in certain places. In this case, they both achieve the same thing, but have different method signatures, as such I am just calling one from the other to "tie up loose ends".

There is then a third owning class that achieves the polymorphism, and needs to be the one to call these methods.

```
class SomeOwningClass : SomeOwningBaseClass
{
    ILogger myLogger;

    #if DEBUG
        myLogger = new LoggerA();
    #else
        myLogger = new LoggerB();
    #endif

    protected override void ProgramLaunched()
    {
        myLogger.SomeMethodBNeeds();
    }

    protected override void ProgramStopped()
    {
    }

    protected override void ProgramResumed()
    {
        myLogger.SomeMethodBNeeds();
    }

    protected override void ProgramPaused()
    {
    }   
}

```

Obviously this should throw a number of red flags at any good developer since it seems the interface is not being used as was intended. If this behavior was intended you wouldn't have to implement every function in the interface, and you wouldn't be simply calling one of the `Log` methods from the other or throwing not-implemented exceptions.

The next thing someone would then think is to use an abstract class, however, LoggerA and LoggerB really do not share code, so would that constitute proper use of an Abstract class?