Refactoring Day 9 : Extract Interface


Today we look at an often overlooked refactoring. Extract Interface. When you notice more than one class using a similar subset of methods on a class, it is useful to break the dependency and introduce an interface that the consumers to use. It’s easy to implement and has benefits from loose coupling.

   1: public class ClassRegistration
   2: {
   3:     public void Create()
   4:     {
   5:         // create registration code
   6:     }
   7:  
   8:     public void Transfer()
   9:     {
  10:         // class transfer code
  11:     }
  12:  
  13:     public decimal Total { get; private set; }
  14: }
  15:  
  16: public class RegistrationProcessor
  17: {
  18:     public decimal ProcessRegistration(ClassRegistration registration)
  19:     {
  20:         registration.Create();
  21:         return registration.Total;
  22:     }
  23: }

In the after example, you can see we extracted the methods that both consumers use and placed them in an interface. Now the consumers don’t care/know about the class that is implementing these methods. We have decoupled our consumer from the actual implementation and depend only on the contract that we have created.

   1: public interface IClassRegistration
   2: {
   3:     void Create();
   4:     decimal Total { get; }
   5: }
   6:  
   7: public class ClassRegistration : IClassRegistration
   8: {
   9:     public void Create()
  10:     {
  11:         // create registration code
  12:     }
  13:  
  14:     public void Transfer()
  15:     {
  16:         // class transfer code
  17:     }
  18:  
  19:     public decimal Total { get; private set; }
  20: }
  21:  
  22: public class RegistrationProcessor
  23: {
  24:     public decimal ProcessRegistration(IClassRegistration registration)
  25:     {
  26:         registration.Create();
  27:         return registration.Total;
  28:     }
  29: }

This refactoring was first published by Martin Fowler and can be found in his list of refactorings here.

This is part of the 31 Days of Refactoring series. For a full list of Refactorings please see the original introductory post.

Refactoring Day 8 : Replace Inheritance with Delegation