工厂方法模式

从UML图可以看出，在工厂方法模式中，工厂类与具体产品类具有平行的等级结构，它们之间是一一对应的。针对UML图的解释如下：

Creator类：充当抽象工厂角色，任何具体工厂都必须继承该抽象类

TomatoScrambledEggsFactory和ShreddedPorkWithPotatoesFactory类：充当具体工厂角色，用来创建具体产品

Food类：充当抽象产品角色，具体产品的抽象类。任何具体产品都应该继承该类

TomatoScrambledEggs和ShreddedPorkWithPotatoes类：充当具体产品角色，实现抽象产品类对定义的抽象方法，由具体工厂类创建，它们之间有一一对应的关系。

工厂方法模式的实现

　　工厂方法模式之所以可以解决简单工厂的模式，是因为它的实现把具体产品的创建推迟到子类中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，这样也就克服了简单工厂模式中缺点。下面看下工厂模式的具体实现代码（这里还是以简单工厂模式中点菜的例子来实现）：

namespace TempApplication
{
    /// <summary>
    /// 菜抽象类
    /// </summary>
    public abstract class Food
    {
        // 输出点了什么菜
        public abstract void Print();
    }
    /// <summary>
    /// 西红柿炒鸡蛋这道菜
    /// </summary>
    public class TomatoScrambledEggs : Food
    {
        public override void Print()
        {
            Console.WriteLine("西红柿炒蛋好了！");
        }
    }
    /// <summary>
    /// 土豆肉丝这道菜
    /// </summary>
    public class ShreddedPorkWithPotatoes : Food
    {
        public override void Print()
        {
            Console.WriteLine("土豆肉丝好了");
        }
    }
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Creator
    {
        // 工厂方法
        public abstract Food CreateFoddFactory();
    }
    /// <summary>
    /// 西红柿炒蛋工厂类
    /// </summary>
    public class TomatoScrambledEggsFactory : Creator
    {
        /// <summary>
        /// 负责创建西红柿炒蛋这道菜
        /// </summary>
        /// <returns></returns>
        public override Food CreateFoddFactory()
        {
            return new TomatoScrambledEggs();
        }
    }
    /// <summary>
    /// 土豆肉丝工厂类
    /// </summary>
    public class ShreddedPorkWithPotatoesFactory : Creator
    {
        /// <summary>
        /// 负责创建土豆肉丝这道菜
        /// </summary>
        /// <returns></returns>
        public override Food CreateFoddFactory()
        {
            return new ShreddedPorkWithPotatoes();
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
            // 初始化做菜的两个工厂（）
            Creator shreddedPorkWithPotatoesFactory = new ShreddedPorkWithPotatoesFactory();
            Creator tomatoScrambledEggsFactory = new TomatoScrambledEggsFactory();
            // 开始做西红柿炒蛋
            Food tomatoScrambleEggs = tomatoScrambledEggsFactory.CreateFoddFactory();
            tomatoScrambleEggs.Print();
            //开始做土豆肉丝
            Food shreddedPorkWithPotatoes = shreddedPorkWithPotatoesFactory.CreateFoddFactory();
            shreddedPorkWithPotatoes.Print();
            Console.Read();
        }
    }  
}
View Code

使用工厂方法实现的系统，如果系统需要添加新产品时，我们可以利用多态性来完成系统的扩展，对于抽象工厂类和具体工厂中的代码都不需要做任何改动。例如，我们我们还想点一个“肉末茄子”，此时我们只需要定义一个肉末茄子具体工厂类和肉末茄子类就可以。而不用像简单工厂模式中那样去修改工厂类中的实现（具体指添加case语句)。具体代码为：

    /// <summary>
    /// 肉末茄子这道菜
    /// </summary>
    public class MincedMeatEggplant : Food
    {
        /// <summary>
        /// 重写抽象类中的方法
        /// </summary>
        public override void Print()
        {
            Console.WriteLine("肉末茄子好了");
        }
    }
 /// <summary>
    /// 肉末茄子工厂类，负责创建肉末茄子这道菜
    /// </summary>
    public class MincedMeatEggplantFactory : Creator
    {
        /// <summary>
        /// 负责创建肉末茄子这道菜
        /// </summary>
        /// <returns></returns>
        public override Food CreateFoddFactory()
        {
            return new MincedMeatEggplant();
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
           
            // 如果客户又想点肉末茄子了
            // 再另外初始化一个肉末茄子工厂
            Creator minceMeatEggplantFactor = new MincedMeatEggplantFactory();
            // 利用肉末茄子工厂来创建肉末茄子这道菜
            Food minceMeatEggplant = minceMeatEggplantFactor.CreateFoddFactory();
            minceMeatEggplant.Print();
            Console.Read();
        }
    }
View Code

反射来实现的工厂方法模式代码:

namespace ConsoleApplication1
{
    /// <summary>
    /// 使用者
    /// </summary>
    class Customer
    {
        static void Main(string[] args)
        {
            //使用者的代码和传统实现一样
            IProduct window = FactoryManager.GetProduct(RoomParts.Window);
            IProduct pillar = FactoryManager.GetProduct(RoomParts.Pillar);
            IProduct roof = FactoryManager.GetProduct(RoomParts.Roof);
            Console.Read();
        }
    }
    /// <summary>
    /// 工厂管理类型
    /// </summary>
    class FactoryManager
    {
        public static IProduct GetProduct(RoomParts part)
        {
            Factory factory = new Factory();
            IProduct product = factory.Produce(part);
            Console.WriteLine("生产了一个产品：" +
                product.GetName());
            return product;
        }
    }

    /// <summary>
    /// 屋子产品的零件
    /// </summary>
    enum RoomParts
    {
        Roof,
        Window,
        Pillar
    }
    /// <summary>
    /// 这个特性用来附加在产品类型之上，
    /// 来标注该类型代码哪个产品，方便反射使用
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    class ProductAttribute : Attribute
    {
        //标注零件的成员
        private RoomParts _myRoomPart;

        public ProductAttribute(RoomParts part)
        {
            _myRoomPart = part;
        }
        public RoomParts RoomPart
        {
            get
            {
                return _myRoomPart;
            }
        }
    }
    /// <summary>
    /// 这个特性用来附加在产品接口之上
    /// 来标注一共实现了多少产品零件，方便反射使用
    /// </summary>
    [AttributeUsage(AttributeTargets.Interface)]
    class ProductListAttribute : Attribute
    {
        private Type[] _myList;

        public ProductListAttribute(Type[] Products)
        {
            _myList = Products;
        }
        public Type[] ProductList
        {
            get
            {
                return _myList;
            }
        }
    }

    #region 产品类族
    /// <summary>
    /// 产品零件接口，
    /// 需要添加所有实现该接口的列表
    /// </summary>
    [ProductList(new Type[]{
                typeof(Roof),
                typeof(Window),
                typeof(Pillar)})]
    interface IProduct
    {
        String GetName();
    }
    /// <summary>
    /// 屋顶类型
    /// </summary>
    [ProductAttribute(RoomParts.Roof)]
    class Roof : IProduct
    {
        public String GetName()
        {
            return "屋顶";
        }
    }
    /// <summary>
    /// 窗户类型
    /// </summary>
    [Product(RoomParts.Window)]
    class Window : IProduct
    {
        public String GetName()
        {
            return "窗户";
        }
    }
    /// <summary>
    /// 柱子类型
    /// </summary>
    [ProductAttribute(RoomParts.Pillar)]
    class Pillar : IProduct
    {
        public String GetName()
        {
            return "柱子";
        }
    }
    #endregion

    #region 工厂类
    /// <summary>
    /// 工厂类型，这里不再需要一个类族，
    /// 而只需要一个工厂类型
    /// </summary>
    class Factory
    {
        public IProduct Produce(RoomParts part)
        {
            //通过反射，从IProduct 接口中获得属性,
            //从而获得所有的产品零件列表
            ProductListAttribute Attr = (ProductListAttribute)
                    Attribute.GetCustomAttribute(typeof(IProduct),
                            typeof(ProductListAttribute));

            //遍历所有的实现产品零件类型
            foreach (Type type in Attr.ProductList)
            {
                //利用反射查找其属性
                ProductAttribute pa = (ProductAttribute)
                                    Attribute.GetCustomAttribute(
                                    type, typeof(ProductAttribute));
                //确定是否是需要的零件
                if (pa.RoomPart == part)
                {
                    //再一次利用反射
                    //创建产品零件类型
                    Object product = Assembly.GetExecutingAssembly().
                        CreateInstance(type.FullName);
                    return product as IProduct;
                }
            }
            //不应该到达这里
            return null;
        }
    }
    #endregion
}
View Code