设计模式作业

using HomeWorkForDisignPattern.Factory;
using System;

namespace HomeWorkForDisignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.WriteLine("Hello World!");
            //工厂模式中着重介绍的是这种通过某个特定的参数，让你一个接口去干对应不同的事而已！而不是调用者知道了类！
            {
                //工厂系列1：
                LiangPi liangPi = new LiangPi();
                RouJiaMo rouJiaMo = new RouJiaMo();
                YangRouPaoMo yangRouPaoMo = new YangRouPaoMo();
                liangPi.Show();
                rouJiaMo.Show();
                yangRouPaoMo.Show();
            }
            {
                //工厂系列2：简单工厂    如果要扩展一种菜，除了这个菜的类之外，简单工厂的分支得加一个
                //优点：把创建都转移到工厂中，集中管理
                //缺点：多了个参数，容易出错 简单工厂的分支频繁变动比较难维护
                AbstractFood liangPi = SimpleFactory.Cook(FoodEnum.LiangPi);
                AbstractFood rouJiaMo = SimpleFactory.Cook(FoodEnum.RouJiaMo);
                AbstractFood yangRouPaoMo = SimpleFactory.Cook(FoodEnum.YangRouPaoMo);
                liangPi.Show();
                rouJiaMo.Show();
                yangRouPaoMo.Show();
            }
            {
                //工厂系列3：工厂    如果要扩展一种菜，除了这个菜的类之外，增加一个工厂
                //优点：把创建都转移到工厂中，集中管理
                //缺点：多包了一层，脱裤子放屁
                {
                    AbstractFood liangPi = LiangPiFactory.Cook();
                    AbstractFood rouJiaMo = RouJiaMoFactory.Cook();
                    AbstractFood yangRouPaoMo = YangRouPaoMoFactory.Cook();
                    liangPi.Show();
                    rouJiaMo.Show();
                    yangRouPaoMo.Show();
                }
                {
                    //工厂的另外一种写法，把所有创建工厂的方法放到一个工厂类中，这个比上个代码量少，类少，更合适
                    AbstractFood liangPi = Factory.Factory.CookLiangPi();
                    AbstractFood rouJiaMo = Factory.Factory.CookRouJiaMo();
                    AbstractFood yangRouPaoMo = Factory.Factory.CookYangRouPaoMo();
                    liangPi.Show();
                    rouJiaMo.Show();
                    yangRouPaoMo.Show();
                }
            }
            {
                Console.WriteLine("**************************************");
                //工厂系列4：抽象工厂  如果要加一个粥，抽象工厂和它的实现类都得增加创建粥的方法
                //优点：产品簇非常清晰
                //缺点：在产品簇中增加一个产品很困难，之前的所有工厂都得加
                //      如果只在自己的工厂中加还好办，就怕抽象工厂增加产品
                //上一桌子陕西菜，就用陕西菜的工厂
                AbstractFactory shaanxi = new ShaanxiFoodFactory();
                AbstractFood liangPi = shaanxi.CookVegetable();
                AbstractSoup yangZaTang = shaanxi.CookSoup();
                liangPi.Show();
                yangZaTang.Show();
                //上一桌子四川菜，就用四川菜的工厂
                AbstractFactory sichuan = new SichuangFoodFactory();
                AbstractFood yuXiangRouSi = sichuan.CookVegetable();
                AbstractSoup yuTouTang = sichuan.CookSoup();
                yuXiangRouSi.Show();
                yuTouTang.Show();
            }

        }
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    public class SimpleFactory
    {
        public static AbstractFood Cook(FoodEnum food)
        {
            switch (food)
            {
                case FoodEnum.RouJiaMo: return new RouJiaMo();
                case FoodEnum.YangRouPaoMo: return new YangRouPaoMo();
                case FoodEnum.LiangPi: return new LiangPi();
            }
            return null;
        }
    }

    public enum FoodEnum
    {
        RouJiaMo,
        YangRouPaoMo,
        LiangPi,
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    public class Factory
    {
        public static LiangPi CookLiangPi()
        {
            return new LiangPi();
        }
        public static RouJiaMo CookRouJiaMo()
        {
            return new RouJiaMo();
        }
        public static YangRouPaoMo CookYangRouPaoMo()
        {
            return new YangRouPaoMo();
        }
    }
    /// <summary>
    /// 把分支拆成一个个工厂，简单对象创建时简直是累赘
    /// </summary>
    public class LiangPiFactory
    {
        public static LiangPi Cook()
        {
            return new LiangPi();
        }
    }
    public class RouJiaMoFactory
    {
        public static RouJiaMo Cook()
        {
            return new RouJiaMo();
        }
    }
    public class YangRouPaoMoFactory
    {
        public static YangRouPaoMo Cook()
        {
            return new YangRouPaoMo();
        }
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    /// <summary>
    /// 抽象工厂--一个产品簇包含一个菜一个汤
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract AbstractFood CookVegetable();//做菜
        public abstract AbstractSoup CookSoup();//做汤
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    /// <summary>
    /// 陕西菜系的工厂--羊杂汤和凉皮
    /// </summary>
    public class ShaanxiFoodFactory : AbstractFactory
    {
        public override AbstractSoup CookSoup()
        {
            return new YangZaTang();
        }

        public override AbstractFood CookVegetable()
        {
            return new LiangPi();
        }
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    /// <summary>
    /// 陕西菜系的工厂--羊杂汤和凉皮
    /// </summary>
    public class SichuangFoodFactory : AbstractFactory
    {
        public override AbstractSoup CookSoup()
        {
            return new YuTouTang();
        }

        public override AbstractFood CookVegetable()
        {
            return new YuXiangRouSi();
        }
    }
}

接下来是业务类

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

namespace HomeWorkForDisignPattern.Factory
{
    /// <summary>
    /// 菜的抽象类
    /// </summary>
    public abstract class AbstractFood
    {
        public abstract void Show();
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    /// <summary>
    /// 汤的抽象类
    /// </summary>
    public abstract class AbstractSoup
    {
        public abstract void Show();
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    public class LiangPi: AbstractFood
    {
        public override void Show()
        {
            Console.WriteLine("凉皮");
        }
    }   
}

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

namespace HomeWorkForDisignPattern.Factory
{
    public class RouJiaMo : AbstractFood
    {
        public override void Show()
        {
            Console.WriteLine("肉夹馍");
        }
    }
}

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

namespace HomeWorkForDisignPattern.Factory
{
    public class YangZaTang : AbstractSoup
    {
        public override void Show()
        {
            Console.WriteLine("羊杂汤");
        }
    }   
}