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.