设计模式之：简单工厂模式、工厂方法模式、抽象工厂模式

一、简单工厂模式（Simple Factory Pattern）
简单工厂模式又称为静态工厂方法（Static Factory Method）模式，通常根据一个条件（参数）来返回不同的类的实例。
严格地来说，它不是一种设计模式，而是一种编程习惯。
示例代码：
public interface ICoat
{
    void GetYourCoat();
}

namespace SimpleFactory
{
    public class BusinessCoat:ICoat
    {
        public void GetYourCoat()
        {
            Console.WriteLine("商务上衣");
        }
    }

    public class FashionCoat : ICoat
    {
        public void GetYourCoat()
        {
            Console.WriteLine("时尚上衣");
        }
    }
}

namespace SimpleFactory
{
    /// <summary>
    /// 简单工厂模式中的核心部分:工厂类
    /// </summary>
    public class Factory
    {
        public ICoat CreateCoat(string styleName)
        {
            switch (styleName.Trim().ToLower())
            {
                case "business":
                    return new BusinessCoat();
                case "fashion":
                    return new FashionCoat();
                default :
                    throw new Exception("还没有你要的那种衣服");
            }
        }
    }
}

/// <summary>
/// 客户端调用
/// </summary>
class Client
{
    static void Main(string[] args)
    {
        ICoat food;
        try
        {
            Factory factory = new Factory();
            Console.Write("我要的是时尚上衣\t");
            food = factory.CreateCoat("fashion");
            food.GetYourCoat();

        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

二、工厂方法模式（Factory Method Pattern）
工厂方法模式又称为工厂模式，也叫虚拟构造器（Virtual Constructor）模式或者多态工厂模式（Polymorphic Factory）,在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
一个工厂类只负责一个对象实例的创建，即工厂类与对象实例之间是一一对应的关系。
示例代码：
namespace FactoryMethod
{
    /// <summary>
    /// 抽象工厂类,定义产品的接口
    /// </summary>
    public interface IFactory
    {
     ICoat CreateCoat();
    }
}

namespace FactoryMethod
{
    /// <summary>
    /// 抽象产品类
    /// </summary>
    public interface ICoat
    {
        void ShowCoat();
    }
}

具体工厂角色代码
namespace FactoryMethod
{
    /// <summary>
    /// 具体工厂类:用于创建商务上衣类
    /// </summary>
    public class BusinessFactory:IFactory
    {       
        public ICoat CreateCoat()
        {
            return new BusinessCoat();
        }
    }

    /// <summary>
    /// 具体工厂类,用于创建时尚上衣
    /// </summary>
    public class FashionFactory : IFactory
    {
        public ICoat CreateCoat()
        {
            return new FashionCoat();
        }
    }
}

namespace FactoryMethod
{
    /// <summary>
    /// 具体产品类,商务上衣类
    /// </summary>
    public class BusinessCoat:ICoat
    {
        public void ShowCoat()
        {
            Console.WriteLine("这件是商务上衣");
        }
    }

    /// <summary>
    /// 具体产品类,时尚上衣类
    /// </summary>
    public class FashionCoat : ICoat
    {
        public void ShowCoat()
        {
            Console.WriteLine("这件是时尚上衣");
        }
    }
}

namespace FactoryMethod
{
    /// <summary>
    /// 客户端代码
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
            //为了方便以后修改,将工厂类的类名写在应用程序配置文件中
            string factoryName = ConfigurationManager.AppSettings["FactoryName"];
            IFactory factory = (IFactory)Assembly.Load("ConcreteFactory").CreateInstance("FactoryMethod." + factoryName);
            ICoat coat = factory.CreateCoat();
            //显示你要的上衣
            coat.ShowCoat();
        }
    }
}

三、抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式管理的是一系列相关或相互依赖对象的创建。
GOF认为，抽象工厂模式“提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。”这里所谓的相关或相互依赖指的是：要求这些对象具有相同的继承体系，并因此而形成一个产品族（Product Family）。
示例代码：
//抽象工厂角色：
namespace AbstractFactory
{
    //抽象工厂类,
    public abstract class AbstractClothes
    {
        //抽象方法:创建一个上衣
        abstract public AbstractCoat CreateCoat();
        //抽象方法:创建一个裤子
        abstract public AbstractTrousers CreateTrousers();
    }
}

//抽象产品角色：
namespace AbstractFactory
{
    /// <summary>
    /// 抽象产品----上衣抽象类
    /// </summary>
    public abstract class AbstractCoat
    {
        //性别属性
        public abstract bool Sex
        {
            get;
        }

        //样式属性
        public abstract string Style
        {
            get;
        }
    }

    /// <summary>
    /// 抽象产品----裤子抽象类
    /// </summary>
    public abstract class AbstractTrousers
    {
        //性别属性
        public abstract bool Sex
        {
           get;
        }

        //样式属性
        public abstract string Style
        {
            get;
        }
    }
}

//具体工厂角色：
namespace AbstractFactory
{
    /// <summary>
    ///时尚男装
    /// </summary>
    public class FashionManClothes:AbstractClothes
    {
        public override AbstractFactory.AbstractCoat CreateCoat()
        {
            return new CoatA();
        }

        public override AbstractTrousers CreateTrousers()
        {
            return new TrousersA();
        }
    }

    /// <summary>
    /// 时尚女装
    /// </summary>
    public class FashionWomanClothes : AbstractClothes
    {
        public override AbstractCoat CreateCoat()
        {
            return new CoatB();
        }
        public override AbstractTrousers CreateTrousers()
        {
            return new TrousersB();
        }
    }
}

//具体产品角色
namespace AbstractFactory
{
    /// <summary>
    /// 时尚男性上衣
    /// </summary>
    public class CoatA:AbstractFactory.AbstractCoat
    {
        private bool sex = true;
        private string style = "时尚";
        /// <summary>
        /// 重写基类的Sex属性
        /// </summary>
        public override bool Sex
        {
            get
            {
                return sex;
            }           
        }
       
        /// <summary>
        /// 重写基类的Style属性
        /// </summary>
        public override string Style
        {
            get
            {
                return style;
            }           
        }
    }

    /// <summary>
    /// 时尚男性裤子
    /// </summary>
    public class TrousersA : AbstractTrousers
    {
        private bool sex = true;
        private string style = "时尚";
        public override bool Sex
        {
            get
            {
                return sex;
            }
        }
        public override string Style
        {
            get
            {
                return style;
            }
        }
    }
}

//客户端代码：
namespace AbstractFactory
{
    /// <summary>
    /// 创建衣服类
    /// </summary>
    public class CreateClothes
    {
        private AbstractCoat myCoat;
        private AbstractTrousers myTrousers;
        public CreateClothes(AbstractClothes clothes)
        {
            myCoat = clothes.CreateCoat();
            myTrousers = clothes.CreateTrousers();
        }

        public void ShowMyClothes()
        {
            Console.WriteLine("My Clothes:");
            string sex= myCoat.Sex ? "男" : "女";
            Console.WriteLine("Coat:{0} {1}", sex, myCoat.Style);
            sex=myTrousers.Sex?"男":"女";
            Console.WriteLine("Trousers:{0} {1}", sex, myTrousers.Style);
        }
    } 
   
    public class Client
    {
        static void Main(string[] args)
        {
            //创建一个工厂类的实例  
            string assemblyName = ConfigurationManager.AppSettings["assemblyName"];
            string fullTypeName =string.Concat( ConfigurationManager.AppSettings["nameSpaceName"] ,".", ConfigurationManager.AppSettings["typename"]);

            AbstractClothes factory = (AbstractClothes)Assembly.Load(assemblyName).CreateInstance(fullTypeName);
            CreateClothes clothes = new CreateClothes(factory);
            clothes.ShowMyClothes();
            Console.Read();
        }       
    }
}

//app.config文件
<configuration>
  <appSettings>
    <!--一般情况下只需改第三个"typename"就行了,具体工厂类    -->
    <add key="assemblyName" value="ConcreteFactory"/>
    <add key="nameSpaceName" value="AbstractFactory"/>
    <add key="typename" value="FashionManClothes"/>
  </appSettings>
</configuration>

本文所引用和摘录的资料来源：
http://www.cnblogs.com/anlyren/archive/2008/01/25/simple_Factory_Pattern.html
http://www.cnblogs.com/yinxiangpei/articles/2366092.html
http://www.cnblogs.com/anlyren/archive/2008/01/31/abstract_factory.html