31天重构指南之三十一：使用多态代码条件判断

31天重构指南的最后一个重构来自于Fowlers的重构目录，你可以在这里查看。

这里展示了面向对象编程的基础之一“多态性”，有时你需要检查对象的类型，并根据类型进行一些操作，在这种情况下将算法封装到类中，并利用多态性进行抽象调用是一个好主意。

   1: public abstract class Customer

   2: {

   3: }

4:

   5: public class Employee : Customer

   6: {

   7: }

8:

   9: public class NonEmployee : Customer

  10: {

  11: }

12:

  13: public class OrderProcessor

  14: {

  15:     public decimal ProcessOrder(Customer customer, IEnumerable<Product> products)

  16:     {

  17:         // do some processing of order

  18:         decimal orderTotal = products.Sum(p => p.Price);

19:

  20:         Type customerType = customer.GetType();

  21:         if (customerType == typeof(Employee))

  22:         {

  23:             orderTotal -= orderTotal * 0.15m;

  24:         }

  25:         else if (customerType == typeof(NonEmployee))

  26:         {

  27:             orderTotal -= orderTotal * 0.05m;

  28:         }

29:

  30:         return orderTotal;

  31:     }

  32: }

在上面的代码中，我们违反了SRP(Single Responsibility Principle)职责，要想对上面的代码进行得构，我们只需要将百分率移除到特定的customer子类中，

   1: public abstract class Customer

   2: {

   3:     public abstract decimal DiscountPercentage { get; }

   4: }

5:

   6: public class Employee : Customer

   7: {

   8:     public override decimal DiscountPercentage

   9:     {

  10:         get { return 0.15m; }

  11:     }

  12: }

13:

  14: public class NonEmployee : Customer

  15: {

  16:     public override decimal DiscountPercentage

  17:     {

  18:         get { return 0.05m; }

  19:     }

  20: }

21:

  22: public class OrderProcessor

  23: {

  24:     public decimal ProcessOrder(Customer customer, IEnumerable<Product> products)

  25:     {

  26:         // do some processing of order

  27:         decimal orderTotal = products.Sum(p => p.Price);

28:

  29:         orderTotal -= orderTotal * customer.DiscountPercentage;

30:

  31:         return orderTotal;

  32:     }

  33: }