【原创】设计模式面对面之工厂模式
简单工厂模式
类图：
常用的实现方式：
产品
public abstract class Product { protected Product(){ } public virtual void Operation(){ Console.WriteLine("我是工厂生产所有产品"); } }//end Product
public class Care : Product { public Care(){ } public override void Operation(){ Console.WriteLine("我生产车！"); } }//end Care
public class Apple : Product { public Apple(){ } public override void Operation(){ Console.WriteLine("我产生苹果"); } }//end Apple
工厂
public class ProductFactory { public ProductFactory(){ } /// /// <param name="productName"></param> public Product Made(string productName) { Product product; switch (productName) { case nameof(Apple): { product= new Apple(); break; } case nameof(Care): { product = new Care(); break; } default: { product=new Apple(); break; } } return product; } }//end ProductFactory
调用
class Program { static void Main(string[] args) { var factory = new ProductFactory(); var car = factory.Made(nameof(Care)); car.Operation(); var apple = factory.Made(nameof(Apple)); apple.Operation(); Console.ReadLine(); } }
使用场景：
简单工厂模式产品工厂提供了一个制造产品万能的类，需要什么产品只要修改made()方法就可以了，很方便。
它是直接new xx()对象的升级版，追求简洁方便开发效率可以考虑使用，或者直接new xx()。
设计原则：
优点
1.遵守了依赖倒置原则---使对象的创建延迟到了之类，不依赖具体产品，只依赖抽象产品
2.遵守了接口隔离原则---产品与产品之间隔离
3.遵守了里氏替换原则--子类实现父类所有方法
缺点
1.违背了对象开-闭原则---工厂对象是一个万能的类，每次扩展新的产品都要维护一次
2.违背了单一职责原则--工厂对象是一个万能的类
3.违背了迪米特法则--工厂对象知道了太多产品对象
抽象工厂方法模式
类图：
常用的实现方式：
产品
public abstract class ProductAbstract { protected ProductAbstract(){ } public abstract void Operation(); }//end ProductAbstractA
public class ProductAbstractAGeneralized : ProductAbstract { public ProductAbstractAGeneralized(){ } public override void Operation(){ Console.WriteLine("生产ProductAbstractA"); } }//end ProductAbstractAGeneralized
public class ProductAbstractBGeneralized : ProductAbstract { public ProductAbstractBGeneralized(){ } public override void Operation(){ Console.WriteLine("生产ProductAbstractB"); } }//end ProductAbstractBGeneralized
工厂
public abstract class FactoryAbstract { protected FactoryAbstract(){ } public abstract ProductAbstract Made(); }//end FactoryAbstractA
public class FactoryAbstractAGeneralized : FactoryAbstract { private readonly ProductAbstract _productAbstractA; public FactoryAbstractAGeneralized(){ _productAbstractA=new ProductAbstractAGeneralized(); } public override ProductAbstract Made(){ return _productAbstractA; } }//end FactoryAbstractAGeneralized
public class FactoryAbstractBGeneralized : FactoryAbstract { private readonly ProductAbstract _productAbstractB; public FactoryAbstractBGeneralized(){ _productAbstractB=new ProductAbstractBGeneralized(); } public override ProductAbstract Made(){ return _productAbstractB; } }//end FactoryAbstractBGeneralized
调用
static void Main(string[] args) { var factoryA = new FactoryAbstractAGeneralized(); var productA = factoryA.Made(); productA.Operation(); var factoryB = new FactoryAbstractBGeneralized(); var productB = factoryB.Made(); productB.Operation(); Console.ReadLine(); }
使用场景：
工厂方法模式是简单工厂模式的升级版，目的是改善简单工厂所违背的设计原则，使其更加完美，主要意图是解耦产品的创建。
它对产品工厂进行了抽象，使不同的产品工厂制造不同的产品，方便以后新产品的扩展，新产品只要泛化一个新工厂就可以了。
设计原则：
优点
1.遵守了依赖倒置原则---使对象的创建延迟到了之类，不依赖具体产品，只依赖抽象产品
2.遵守了接口隔离原则---产品与产品之间隔离
3.遵守了里氏替换原则--子类实现父类所有方法
4遵守了对象开-闭原则---产品的创建只要泛化工厂就可以了，扩展好
5.遵守了单一职责原则--一个工厂一个产品，修改工厂逻辑不影响其它工厂
6.遵守了迪米特法则--工厂只知道所要创建的产品，其它产品信息不知道，知道的非常少。
缺点
1.很明显，产品一多，工厂跟着多，后期不好维护，所以有了抽象工厂模式。
抽象工厂模式
类图：
常用的实现方式：
产品
public abstract class ProductAbstractA { protected ProductAbstractA(){ } public abstract void Operation(); }//end ProductAbstractA
public class ProductAbstractAGeneralized1 : ProductAbstractA { public ProductAbstractAGeneralized1(){ } public override void Operation(){ Console.WriteLine("生产组1：ProductAbstractAGeneralized1"); } }//end ProductAbstractAGeneralized1
public abstract class ProductAbstractB { protected ProductAbstractB(){ } public abstract void Operation(); }//end ProductAbstractB
public class ProductAbstractBGeneralized1 : ProductAbstractB { public ProductAbstractBGeneralized1(){ } public override void Operation(){ Console.WriteLine("生产组1：ProductAbstractBGeneralized1"); } }//end ProductAbstractBGeneralized1
工厂
public abstract class FactoryAbstract { protected FactoryAbstract() { } public abstract ProductAbstractA MadeProductA(); public abstract ProductAbstractB MadeProductB(); }
public class FactoryAbstractGroup1Generalized : FactoryAbstract { public FactoryAbstractGroup1Generalized(){ } public override ProductAbstractA MadeProductA(){ return new ProductAbstractAGeneralized1(); } public override ProductAbstractB MadeProductB(){ return new ProductAbstractBGeneralized1(); } }//end FactoryAbstractAGeneralized
调用
static void Main(string[] args) { var productGroup= new FactoryAbstractGroup1Generalized(); var groupProduct1 = productGroup.MadeProductA(); groupProduct1.Operation(); var groupProduct2 = productGroup.MadeProductB(); groupProduct2.Operation(); Console.ReadLine(); }
使用场景：
抽象工厂模式是抽象工厂方法模式的升级版，唯一的区别是泛化的工厂少了，维护的工厂对象少了，使工厂模式更加完美了。
抽象工厂会针对一组有关联或者相互依赖的产品做抽象，所以泛化的工厂会创建一组产品而不是一个产品。
所谓的关联指的是创建产品的方式关联或者产品间的直接关联（依赖），可以按照这些关联将它们归为一组产品去维护。比如生产床头柜和床，生产的时候床头柜和床都要遵守高低尺寸和风格搭配这些约束，此时我们可以将床头柜和床抽象成一个组产品去维护。
所谓的相互依赖指的是不同产品间是依赖关系，比如手机和电池，二者相互依赖，分离了就没意义了，生产的时候需要抽象为一组产品去维护。
优点
1.遵守了依赖倒置原则---使对象的创建延迟到了之类，不依赖具体产品，只依赖抽象产品
2.遵守了接口隔离原则---产品与产品之间隔离
3.遵守了里氏替换原则--子类实现父类所有方法
4遵守了对象开-闭原则---产品的创建只要泛化工厂就可以了，扩展好
5.遵守了单一职责原则--一个工厂一个产品，修改工厂逻辑不影响其它工厂
6.遵守了迪米特法则--工厂只知道所要创建的产品，其它产品信息不知道，知道的非常少。
7.减少了工厂对象维护量
缺点
1.很明显，需要根据自己的理解去合理的抽象，抽象（抽象层次要把握好）错了反而适得其反，增加了对象创建的复杂度。
三种工厂模式各有优缺点，使用的时候需要根据场景去判断，选择最优方式。
