重构第11天 使用策略代替Switch(Switch to Strategy)

理解：策略就是平常设计模式中所说的策略模式。因为当你有一个庞大的switch方法的时候，每一次新加一个条件，都要去修改这个方法，这样耦合性太高，不易维护也不易扩展。这样我们就可以使用策略的设计模式，使得每一种情况都封装在自己的类中，来提高扩展性和降低耦合性。

详解：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _31DaysRefactor
{

    public class ClientCode
    {

        public decimal CalculateShipping()
        {
            ShippingInfo shippinginfo = new ShippingInfo();

            return shippinginfo.CalclateShippingAmount(State.Alaska);
        }

    }


    public enum State
    {
        Alaska,
        NewYork,
        Florida
    }

    public class ShippingInfo
    {

        public decimal CalclateShippingAmount(State shipToState)
        {
            switch (shipToState)
            {
                case State.Alaska:
                    return GetAlaskaShippingAmount();
                case State.NewYork:
                    return GetNewYorkShippingAmount();
                case State.Florida:
                    return GetFloridaShippingAmount();
                default:
                    return 0m;
            }
        }

        private decimal GetAlaskaShippingAmount()
        {
            return 15m;
        }

        private decimal GetNewYorkShippingAmount()
        {
            return 10m;
        }

        private decimal GetFloridaShippingAmount()
        {
            return 3m;
        }
    }
}

为了完成switch重构，我们需要把每一种条件封装成一个独立的类，然后这些类提取出一个公共接口，每个类都实现该接口。下次如果你想添加新的条件，只需要新增一个实现该公共接口的类即可。

这里我们提取出一个公共接口IShippingCalculation，这个类包含一个方法decimal Caculate()和一个属性 State State { get; }。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _31DaysRefactor
{

    public class ClientCode
    {

        public decimal CalculateShipping()
        {
            IShippingInfo shippingInfo = new ShippingInfo();
            return shippingInfo.CalculateShippingAmount(State.Alaska);
        }

    }


    public enum State
    {
        Alaska,
        NewYork,
        Florida
    }


    public interface IShippingCalculation
    {
        decimal Caculate();
    }

    public interface IShippingInfo
    {
        decimal CalculateShippingAmount(State state);
    }

    public class ShippingInfo : IShippingInfo
    {
        private IDictionary<State, IShippingCalculation> ShippingCalculations { get; set; }

        public ShippingInfo()
        {
            ShippingCalculations = new Dictionary<State, IShippingCalculation>(){
                {State.Alaska,new AlaskShippingCaculation()},
                {State.Florida,new FloridaShippingCaculation()},
                {State.NewYork,new NewYorkShippingCaculation()}
            };
        }

        public decimal CalculateShippingAmount(State shipToState)
        {
            return this.ShippingCalculations[shipToState].Caculate();
        }

    }


    public class AlaskShippingCaculation : IShippingCalculation
    {
        public State State { get { return State.Alaska; } }

        public decimal Caculate()
        {
            return 15m;
        }
    }


    public class NewYorkShippingCaculation : IShippingCalculation
    {
        public State State { get { return State.NewYork; } }

        public decimal Caculate()
        {
            return 10m;
        }
    }


    public class FloridaShippingCaculation : IShippingCalculation
    {
        public State State { get { return State.Florida; } }

        public decimal Caculate()
        {
            return 3m;
        }
    }
}