再谈工厂模式

申明一下：以下文章是我转载而来，里面写有自已的一些心得

 今天认真的看了一下抽像工
抽象工厂（Abstract Factory)
声明生成一系列抽象产品的方法
具体工厂（Concrete Factory）
执行生成一系列抽象产品的方法，生成一系列具体的产品
抽象产品（Abstract Product）
为这一系列的某一种产品声明接口
具体产品（Product）
定义具体工厂生成的具体产品的对象，实现产品接口
客户（Client）
我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。

抽象工厂：虚拟的衣柜，它只是个概念而已。在项目中可能是一个接口或抽象类，定义规则，取出上衣，裤子。
具体工厂：具体的存在的衣柜，它用于存放某一种成套的衣服，换句话说，这种成套的衣服都是从这个衣柜中取出的。在项目中继承于抽象工厂，实现抽象工厂中的方法，取出具体产品，某一件上衣，某一条裤子。
抽象产品：虚拟的衣服，也只是个概念。在项目中可能是多个接口或抽象类，定义规则，有什么特性，起什么作用。
具体产品：具体的实际存在的产品，它指的就是用于组装成某一套衣服的某一件上衣或裤子。它继承自某一个抽象产品。实现抽象产品中制定的规则，特性。

工厂： 可以看成一个工厂的许多性质的概括，具体工厂来实现性质
 public abstract class AbstractClothes
 5    {
 6        //抽象方法:创建一个上衣
 7        abstract public AbstractCoat CreateCoat();  //这里AbstractCoat
 8        //抽象方法:创建一个裤子                 //
 9        abstract public AbstractTrousers CreateTrousers();  //这里AbstractTrousers
10    }

具体工厂：具体工厂可以生成很多的产品。

 1namespace AbstractFactory
 2{
 3    /** <summary>
 4    ///时尚男装
 5    /// </summary>
 6    public class FashionManClothes:AbstractClothes
 7    {
 8        public override AbstractFactory.AbstractCoat CreateCoat() //一个抽像类AbstractCoat
 9        {
10            return new CoatA();    //这里生成一个具体的产品类
11        }
12
13        public override AbstractTrousers CreateTrousers() //一个抽像类AbstractTrousers
14        {
15            return new TrousersA();  //这里生成一个具体的产品类
16        }
17    }
18
19    /** <summary>
20    /// 时尚女装
21    /// </summary>
22    public class FashionWomanClothes : AbstractClothes
23    {
24        public override AbstractCoat CreateCoat()
25        {
26            return new CoatB();  //这里生成一个具体的产品类
27            //throw new Exception("The method or operation is not implemented.");
28        }
29        public override AbstractTrousers CreateTrousers()
30        {
31            return new TrousersB();  //这里生成一个具体的产品类
32            //throw new Exception("The method or operation is not implemented.");
33        }
34    }
35}

抽像产品：它包括了许多的产品的特性，具体产品从这个类当中去继承从而去实现它。

 1namespace AbstractFactory
 2{
 3    /** <summary>
 4    /// 抽象产品----上衣抽象类
 5    /// </summary>
 6    public abstract class AbstractCoat
 7    {
 8        //性别属性
 9        public abstract bool Sex
10        {
11            get;
12        }
13
14        //样式属性
15        public abstract string Style
16        {
17            get;
18        }
19    }
20
21    /** <summary>
22    /// 抽象产品----裤子抽象类
23    /// </summary>
24    public abstract class AbstractTrousers
25    {
26        //性别属性
27        public abstract bool Sex
28        {
29            get;
30        }
31
32        //样式属性
33        public abstract string Style
34        {
35            get;
36        }
37    }
38}

具体产品： 继承了抽像产品类，也就是说具体到哪一种产品。

/** <summary>
 4    /// 时尚男性上衣
 5    /// </summary>
 6    public class CoatA:AbstractFactory.AbstractCoat
 7    {
 8        private bool sex = true;
 9        private string style = "时尚";
10        /** <summary>
11        /// 重写基类的Sex属性
12        /// </summary>
13        public override bool Sex
14        {
15            get
16            {
17                return sex;
18            }           
19        }
20       
21        /** <summary>
22        /// 重写基类的Style属性
23        /// </summary>
24        public override string Style
25        {
26            get
27            {
28                return style;
29            }           
30        }
31    }
32
33    /** <summary>
34    /// 时尚男性裤子
35    /// </summary>
36    public class TrousersA : AbstractTrousers
37    {
38        private bool sex = true;
39        private string style = "时尚";
40        public override bool Sex
41        {
42            get
43            {
44                return sex;
45            }
46        }
47        public override string Style
48        {
49            get
50            {
51                return style;
52            }
53        }
54    }

 

在客户端可以这样的调用

public class CreateClothes
 7    {
 8        private AbstractCoat myCoat;
 9        private AbstractTrousers myTrousers;
10        public CreateClothes(AbstractClothes clothes)
11        {
12            myCoat = clothes.CreateCoat();
13            myTrousers = clothes.CreateTrousers();
14        }
15
16        public void ShowMyClothes()
17        {
18            Console.WriteLine("My Clothes:");
19            string sex= myCoat.Sex ? "男" : "女";
20            //Console.WriteLine("Coat:{0} {1}", myCoat.Sex ? "男" : "女", myCoat.Style);
21            Console.WriteLine("Coat:{0} {1}", sex, myCoat.Style);
22            sex=myTrousers.Sex?"男":"女";
23            Console.WriteLine("Trousers:{0} {1}", sex, myTrousers.Style);
24        }
25    } 

public class Client
29    {
30        static void Main(string[] args)
31        {
32            //创建一个工厂类的实例  
33            string assemblyName = ConfigurationManager.AppSettings["assemblyName"];
34            string fullTypeName =string.Concat( ConfigurationManager.AppSettings["nameSpaceName"] ,".", ConfigurationManager.AppSettings["typename"]);
35
36            AbstractClothes factory = (AbstractClothes)Assembly.Load(assemblyName).CreateInstance(fullTypeName);  //这里通过反射来生成一个抽像工厂类的实例
37            CreateClothes clothes = new CreateClothes(factory); //显示信息，
38            clothes.ShowMyClothes();
39            Console.Read();
40        }       
41    }

基本上是两个，抽像类和反射，

抽像类：车就是一个抽像类，它可以有车严色，车大小

继承类：有具体的严色，具体的大小。