商品价格加价区间的实现（策略模式）

前言：

好久之前，某个网友提的需求，对商品进行加价，根据原商品的价格不同，加价的方式不同。

具体如下：

250元以下 按比率10%以内加价
251~500 加价 25元以下
501~5000  按比率 5%以内加价
5000以上 加价250元以下
比如某种商品价格是：6000或者10000按照5000元以上的标准调。

分析：

首先，加价是一个范围，因此我们先定义一个结构，PriceRange：

public struct PriceRange
    {
        public decimal MaxPrice { get; set; }
        public decimal MinPrice { get; set; }
    }

对于加价相关的逻辑，有两种，一种为固定加价，一种为按比率加价，因此利用策略模式处理如下（英文类名请无视，硬伤）：

 public interface IPriceStrategy
    {
        PriceRange GetPriceRange(decimal purchasePrice);
    }

    /// <summary>
    /// 固定加价策略
    /// </summary>
    public class FixedPriceStrategy : IPriceStrategy
    {
        private decimal _fixedPrice;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fixedPrice">加价金额</param>
        public FixedPriceStrategy(decimal fixedPrice)
        {
            this._fixedPrice = fixedPrice;
        }

        public PriceRange GetPriceRange(decimal purchasePrice)
        {
            return new PriceRange()
            {
                MinPrice = purchasePrice,
                MaxPrice = purchasePrice + _fixedPrice,
            };
        }
    }

    /// <summary>
    /// 百分比加价策略
    /// </summary>
    public class PercentagePriceStrategy : IPriceStrategy
    {
        private decimal _percent;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="percent">加价率</param>
        public PercentagePriceStrategy(decimal percent)
        {
            this._percent = percent;
        }

        public PriceRange GetPriceRange(decimal purchasePrice)
        {
            return new PriceRange()
            {
                MinPrice = purchasePrice,
                MaxPrice = purchasePrice * (1 + _percent),
            };
        }
    }

最后需要一个工具类，封装相关加价逻辑，并暴漏一个方法出来：

PS：这里设计：每种加价策略的低价作为key，放到字典中。 获取加价区间时，取小于或等于 传入价格的所有Key中最大的一个(如果没有，则取最大的Key），即为最终的加价策略！

这样设计的好处：可以避免大量的if 和else if 。。。

public class PriceUtility
    {
        /// <summary>
        /// 相关加价策略
        /// </summary>
        private static Dictionary<decimal, IPriceStrategy> Dic = new Dictionary<decimal, IPriceStrategy>();

        static PriceUtility()
        {
            //初始化加价规则（todo：这里是写死的，如果需求多变，也可以从外部存储获取并初始化）
            Dic.Add(0, new PercentagePriceStrategy(0.1m));
            Dic.Add(250, new FixedPriceStrategy(25));
            Dic.Add(500, new PercentagePriceStrategy(0.05m));
            Dic.Add(5000, new FixedPriceStrategy(250));
        }

        /// <summary>
        /// 获取加价区间
        /// </summary>
        /// <param name="purchasePrice"></param>
        /// <returns></returns>
        public static PriceRange GetRange(decimal purchasePrice)
        {
            var key = GetCurrentKey(purchasePrice);

            return Dic[key].GetPriceRange(purchasePrice);
        }

        /// <summary>
        /// 获取符合条件的Key
        /// </summary>
        /// <param name="purchasePrice"></param>
        /// <returns></returns>
        private static decimal GetCurrentKey(decimal purchasePrice)
        {
            //找到小于等于该价格的所有Key
            var keys = Dic.Keys.Where(r => r.CompareTo(purchasePrice) <= 0).ToArray();
            //如果没有，则取最大的
            if (keys.Length == 0) return Dic.Keys.Max();
            //有则在找到的Key中取最大的
            return keys.Max();
        }
    }

结果：

用控制台应用程序测试一下：

static void Main(string[] args)
        {
            ConsolePriceRange(100);
            ConsolePriceRange(240);
            ConsolePriceRange(250);
            ConsolePriceRange(490);
            ConsolePriceRange(500);
            ConsolePriceRange(4900);
            ConsolePriceRange(5000);
            ConsolePriceRange(10000);

            Console.ReadKey();
        }

        static void ConsolePriceRange(decimal price)
        {
            PriceRange range = PriceUtility.GetRange(price);

            Console.WriteLine("产品价格{0}的加价区间为：{1}~{2}", price, range.MinPrice, range.MaxPrice);
        }