Lets consider a class ClassA that needs an instance of another class ClassB, I can pass in this class in ClassA's constructor;public class ClassA{    private readonly ClassB _classB;    public ClassA(ClassB classB)    {        _classB = classB;    }}public class ClassB{    public void Method1() { }    public void Method2() { }    public void Method3() { }    public void Method4() { }}I understand that this causes issues because ClassA now has a dependency on a concrete type, also if I write some unit tests they would not purely be testing ClassA (so strictly speaking they would be integration tests). To solve both of these I could either create an abstract base class or an interface that ClassB could implement and then inject this into the constructor instead. My issue is this; I would only have a single concrete implementation of the base class (ignoring implementations created purely for the sake of unit testing). I would end up creating abstract base classes for all types that I create, many of which would never have more than one implementation. This seems like a waste of time and adds to the complexity of the code. Does the benefit of having all those abstractions really out-weigh the cost? Could I not simply inject concrete types (e.g. ClassB) and if there is a need for a different implementation simply convert the concrete implementation into an abstract base class and then subclass from that? 
Should I create interfaces/abstract base classes when I only have a single implementation?
c#;unit testing;dependency injection