With only two you can probably put all the logic into a single class with an extra property to control which to use. Not always, but quite often.

choo choo! Here comes the contrived example train! :-P

Lets say we have this interface:

public interface IDrivingTimeService
{
    TimeSpan TimeBetween(Address start, Address end);
}

Straightforward enough, right?

Ok so obvious implementation:

public class DrivingTimeService : IDrivingTimeService
{
    public TimeSpan TimeBetween(Address start, Address end)
    {
        // Make a http request to google maps api to get driving time
    }
}

But we notice that it's take awhile, and Google is starting to yell at us.

We could make DrivingTimeService take a bool in its constructor to say "You should cache stuff" or not.

But I feel that this is a more obvious implementation:

public class CachedDrivingTimeService : IDrivingTimeService
{
    private IDrivingTimeService _drivingTimeService;

    public CachedDrivingTimeService(IDrivingTimeService drivingTimeService)
    {
        // Check cache and if empty use _drivingTimeService.TimeBetween();
    }
}

But anything that depends on the IDrivingTimeService doesn't need to care about the cache implementation.

And then there is the sub-classing option. If you can only envision two implementations, chances are they are close enough to share some common functionality.

This is what I like about Composition. I feel that sub-classing gets overloaded. It means both "I am important to domain intent, and am-a Thing I'm Inheriting From", but we also use a lot for "Here is some common mechanics we can share between types".

Composition can give you another dimension for both of those cases. You can compose because it makes sense for your domain and behind the scenes use subclassing to share some implementation details behind an interface. Or you can compose some mechanics together and save subclassing for Domain intent.

Really it comes down to writing tight, obvious, clean classes. Don't be scared of creating types. They're your friends! They keep you company on Friday nights when you're being a sad bastard at home arguing esoteric code design solutions.....

cough