Design patterns 在这个例子中，装饰器模式真的有必要吗？

这是问题陈述

一家餐厅有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"])

公共级比萨饼{
public int getPrice（基本、字符串…顶部）{
PizzaBaseMap.get（base）+toppingsMap.sum（t->toppingsMap.get（t））
}
Hashmap PizzaBaseMap={
全麦：1
木火：2
奶酪馅：2
薄壳：4
}
Hashmap toppingsMap={
番茄：1
洋葱：2
奶酪：4
佩波罗尼：5
辣椒：2
大蒜：2
paneer:4
土豆：4
}
//客户端代码
int Price=new Pizza（）.getPrice（“全麦”、“西红柿”、“奶酪”）

我真的需要像Headfirst desgin模式手册在其示例中建议的那样使用装饰器吗？使用装饰器模式的解决方案如下所示：

    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();

            }

公共接口iPizza
{
双重成本（）；
}
//装饰师
公共接口iToppingDecorator:iPizza
{
}
//比萨饼类型
全班披萨：iPizza
{
公共双重成本（）
{
}
}
木火类：伊皮扎
{
公共双重成本（）
{
}
}
奶酪类：iPizza
{
公共双重成本（）
{
}
}
类Thincrust:iPizza
{
公共双重成本（）
{
}
}
//继承装饰器接口的浇头
奶酪类：iToppingDecorator
{
伊皮萨比萨饼；
公共芝士店（iPizza Pizza型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
TomatoToping类：iToppingDecorator
{
伊皮萨比萨饼；
公共番茄酱（iPizza比萨型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
类OnOnOnToping:iToppingDecorator
{
伊皮萨比萨饼；
公共洋葱盖（iPizza pizzatype）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
PEPPORONTIPTING类：ITOPPINGDECOCTOR
{
伊皮萨比萨饼；
公共Pepporonitating（iPizza Pizza型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
等级：iToppingDecorator
{
伊皮萨比萨饼；
公共浇头（iPizza Pizza型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
类别PaneerTopping:iToppingDecorator
{
伊皮萨比萨饼；
公共PaneerTopping（iPizza Pizza类型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
分类：iToppingDecorator
{
伊皮萨比萨饼；
公共大蒜头（iPizza Pizza型）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
PotatoTopping类：iToppingDecorator
{
伊皮萨比萨饼；
公共PotatoTopping（iPizza pizzatype）
{
this.pizza=pizzatype；
}
公共双重成本（）
{
return+pizza.cost（）；
}
}
//客户
静态void Main（）
{
iPizza pizza1=新的全热比萨饼（）；
pizza1=新奶酪配料（pizza1）；
Console.WriteLine（“pizza1成本：+pizza1.cost（）+INR”）；
iPizza pizza2=新的WoodFire（）；
pizza2=新奶酪配料（pizza2）；
pizza2=新番茄顶（pizza2）；
Console.WriteLine（“pizza2成本：+pizza2.cost（）+INR”）；
Console.ReadLine（）；
}

---

我只是觉得这是一个完全的杀伤力，我的代码和使用decorator模式的解决方案一样具有可扩展性。有什么想法吗？

是的，在这种情况下，这可能是杀伤力过大。但是，想象一下一个更大的应用程序，有更多的浇头；或者价格修饰符更复杂；或者您正在构建一个可重用的库

在这些情况下，decorator模式有两个优点：

您可以独立地从代码库中添加和删除装饰器，因为每个装饰器的行为都完全包含在其类中

对象的装饰方式可以根据每个装饰者进行定制

例如，假设我们有一个特价，任何含凤尾鱼的比萨都可以打八折（不要吃凤尾鱼！）。使用散列图，这相当麻烦：

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

使用decorator模式，我们只需添加一个新类：

class AnchoviesToppingDecorator : IPizzaToppingDecorator
{
    private IPizza pizza;

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

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

当然，decorator应用程序的顺序变得很重要。如果需要，可以使用类型系统来强制执行

---

你可以强制执行命令

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;
    }
}

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

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