Both class inheritance and interfaces both have their place. Inheritance means "is a" while an interface provides a contract that defines what something "behaves like".
I would say that using interfaces more often is not a bad practice at all. I am currently reading "Effective C# - 50 Specific Ways to Improve Your C#" by Bill Wagner. Item number 22 states, and a I quote, "Prefer Defining and Implementing Interfaces to Inheritance".
Generally I use base classes when I need to define a specific implementation of common behavior between conceptually related types. More often I use interfaces. In fact, I normally start by defining an interface for a class when I start to create one...even if in the end I don't compile the interface, I find that it helps to start off by defining the public API of the class from the get go. If I find that I have multiple classes both implementing the interface, and the implementation logic is identical, only then will I ask myself whether or not it would make sense to implement a common base class between the types.
A couple of quotes from Bill Wagners book...
"Abstract base classes can supply some implementation for derived types, in addition to describing the common behavior. You can specify data members, concrete methods, implementation for virtual methods, properties, events, and indexers. A base class can provide implementation for some of the methods, thereby providing common implementation reuse. Any of the elements can be virtual, abstract, or nonvirtual. An abstract base class can provide an implementation for any concrete behavior; interfaces cannot. This implementation reuse provides another benefit: If you add a method to the base class, all derived classes are automatically and implicitly enhanced. In that sense, base classes provide a way to extend the behavior of several types efficiently over time: By adding and implementing functionality in the base class, all derived classes immediately incorporate that behavior. Adding a member to an interface breaks all the classes that implement that interface. They will not contain the new method and will no longer compile. Each implementer must update that type to include the new member. Choosing between an abstract base class and an interface is a question of how best to support your abstractions over time. Interfaces are fixed: You release an interface as a contract for a set of functionality that any type can implement. Base classes can be extended over time. Those extensions become part of every derived class. The two models can be mixed to reuse implementation code while supporting multiple interfaces."
"Coding interfaces provides greater flexibility to other developers than coding to base class types."
"Using interfaces to define APIs for a class provides greater flexibility."
"When your type exposes properties as class types, it exposes the entire interface to that class. Using interfaces, you can choose to expose only the methods and properties you want clients to use."
"Base classes describe and implement common behaviors across related concrete types. Interfaces describe atomic pieces of functionality that unrelated concrete types can implement. Both have their place. Classes define the types you create. Interfaces describe the behavior of those types as pieces of functionality. If you understand the differences, you will create more expressive designs that are more resilient in the face of change. Use class hierarchies to define related types. Expose functionality using interfaces implemented across those types."