这个例子中真的需要装饰器模式吗？

Question

这里是问题陈述

一家餐厅有 4 个披萨基地：

全麦披萨
木火披萨
芝士披萨
薄皮披萨

有8种浇头：

番茄、洋葱、奶酪、意大利辣香肠、辣椒、大蒜、芝士、土豆，

计算给定比萨底料和 0 种或更多配料的比萨饼价格（假设每个底料和配料都配置了一些价格）。

我对此的伪代码解决方案是：

    public class Pizza {
        public int getPrice(base, String... toppings){
            PizzaBaseMap.get(base) + toppingsMap.sum(t -> toppingsMap.get(t))
        }



    Hashmap<String, int> PizzaBaseMap= {
        whole_wheat : 1
        wood_fire : 2
        cheese_filled : 2
        thin_crust : 4
    }

    Hashmap<String, int> toppingsMap = {
        tomato : 1
        onion : 2
        cheese : 4
        pepporoni : 5
        capsicum : 2
        garlic : 2
        paneer : 4
        potato : 4
    }

    //client Code 

    int Price = new Pizza().getPrice("whole_wheat", ["tomato", "cheese"])

我真的需要像 Headfirst 设计模式书中的示例中建议的那样使用装饰器吗？带有装饰器模式的解决方案看起来像这样：

    public interface iPizza
        {
             double cost();
        }

    //Decorator
    public interface iToppingDecorator:iPizza
    {
    }

    //Pizza types
    class WholeWheatPizza:iPizza
        {
            public double cost()
            {

            }
        }

    class WoodFire : iPizza
        {
            public double cost()
            {

            }
        }

     class CheeseFilled : iPizza
        {
            public double cost()
            {

            }
        }

      class Thincrust : iPizza
        {
            public double cost()
            {

            }
        }

    //Toppings inheriting Decorator Interface

    class CheeseTopping:iToppingDecorator
        {
             iPizza pizza;
             public CheeseTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost(); 
            }
        }

     class TomatoTopping:iToppingDecorator
        {
            iPizza pizza;
            public TomatoTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class OnionTopping:iToppingDecorator
        {
            iPizza pizza;
            public OnionTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class PepporoniTopping:iToppingDecorator
        {
            iPizza pizza;
            public PepporoniTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class CapsicumTopping:iToppingDecorator
        {
            iPizza pizza;
            public CapsicumTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class PaneerTopping:iToppingDecorator
        {
            iPizza pizza;
            public PaneerTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class GarlicTopping:iToppingDecorator
        {
            iPizza pizza;
            public GarlicTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

     class PotatoTopping:iToppingDecorator
        {
            iPizza pizza;
            public PotatoTopping(iPizza pizzatype)
            {
                this.pizza = pizzatype;
            }

            public double cost()
            {
                return <price> + pizza.cost();
            }
        }

    //client
    static void Main()
            {
                iPizza pizza1 = new WholeWheatPizza();
                pizza1 = new CheeseTopping(pizza1);

                Console.WriteLine("Pizza 1 cost: "+pizza1.cost()+"INR");

                iPizza pizza2 = new WoodFire();
                pizza2 = new CheeseTopping(pizza2);
                pizza2 = new TomatoTopping(pizza2);
                Console.WriteLine("Pizza 2 cost: " + pizza2.cost() + "INR");

                Console.ReadLine();

            }

我只是觉得这完全是矫枉过正，我的代码与装饰器模式的解决方案一样具有可扩展性。有什么想法吗？

Answer 1

是的，在这种情况下它可能有点矫枉过正。然而，想象一个更大的应用程序，有更多的配料；或价格修正更复杂的地方；或者您正在构建一个可重用的库。

在这些情况下，装饰器模式有两个优势：

您可以独立地从代码库中添加和删除装饰器，因为每个装饰器的行为都完全包含在其 class 中。
可以在每个装饰器的基础上自定义装饰对象的方式

例如，假设我们有一个特别优惠，任何带有凤尾鱼的披萨都可以享受 20% 的折扣（不要吃凤尾鱼！）。使用哈希图，这非常麻烦：

foreach (var topping in toppings)
    if (topping is Anchovies)
        price := price * 0.8
    else
        price := price - toppingCosts[topping]

使用装饰器模式，我们可以添加一个新的class：

class AnchoviesToppingDecorator : IPizzaToppingDecorator
{
    private IPizza pizza;

    public AnchoviesTopping(IPizza pizza)
    {
        this.pizza = pizza;
    }

    public double cost()
    {
        return this.pizza.Cost() * 0.8f;
    }
}

当然，装饰器应用的顺序就变得很重要了。如有必要，可以使用类型系统强制执行此操作。

您可以使用类型系统对装饰器强制执行顺序。假设所有 topping 装饰器必须在 discount 装饰器之前。在我们的系统中，装饰器通过它们的构造函数接受它们的前任。通过更改构造函数类型，我们可以限制我们可以构建的装饰器。

interface IPizzaToppingDecorator : IPizzaDecorator
{

}

interface IPizzaDiscountDecorator : IPizzaDecorator
{

}

public class HalfPriceDecorator : IPizzaDiscountDecorator 
{
    private IPizzaToppingDecorator pizzaToppingDecorator;

    public HalfPriceDecorator(IPizzaToppingDecorator pizzaToppingDecorator)
    {
        this.pizzaToppingDecorator = pizzaToppingDecorator;
    }

    public double Cost()
    {
        pizzaToppingDecorator.Cost() * 0.5;
    }
}

请注意构造函数如何采用 IPizzaToppingDecorator 而不是 IPizzaDecorator。这确保 HalfPriceDecorator 只能在 IPizzaToppingDecorator 之后应用。

任何其他都会抛出编译时错误；我们喜欢编译时错误，因为只有我们才能看到它们！

在这种情况下，我认为 Head First 示例可以通过流畅的界面进行改进。

能写这个不是很好吗？

new WholeWheatPizza().WithTomatoTopping().WithCheeseTopping().WithPepporoniTopping();

这可以通过 extension methods 实现：

public static IPizza WithCheeseTopping(this IPizza pizza)
{
    return new CheeseToppingDecorator(pizza)
}

这个例子中真的需要装饰器模式吗？

is the decorator pattern really necessary in this example?

design-patterns