using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 抽象工厂模式
{
/*
* 抽象工厂模式的意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
* 抽象工厂模式的实现技巧：1、将抽象工厂建产品对象的创建延迟到它的具体工厂子类。
* 2、如果没有应对“多系列对象的”需求变化，则没有必要使用抽象工厂，这是使用简单的静态工厂就可以胜任了。
* 3、系列对象指的是这些对象之间相互依赖或相互作用的关系，例如游戏场景开发中道路与房屋的依赖，道路与地道的依赖
* 4、抽象工厂模式经常和工厂方法模式共同组合来应对“对象创建”的需求变化，即用工厂方法模式来创建单个产品，而用抽象工厂模式创建产品族
* 5、通常在运行时刻创建一个具体工厂的实例，这一具体工厂的创建具体有特定实现的产品对象，为创建不同的产品对象，客户应使用不同的具体工厂。
* 6、把工厂做为单件时，一个应用中一般每个产品系列只需要一个工厂实例，因此工厂通常最好实现一个单件模式。
* 7、创建产品，抽象工厂仅声明一个创建产品的接口，真正出创建产品的是由具体产品类创建的，
* 通常的办法是为每一个产品定义一个工厂方法，一个具体的工厂将为每个产品重定义该工厂方法以指定产品，
* 虽然这样的实现很简单，但它却要求每个产品系列都有一个具体的工厂子类，即使这些产品系列的差别很小。
*
* 抽象工厂模式的优点：1、分离了具体的类，抽象向工厂模式帮助你控制一个应用创建对象的类，因为工厂封装了创建产品对象的责任和过程，
* 它将客户和类的实现分离，客户通过他们的抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，
* 他们不出现在客户代码中。
* 2、抽象工厂模式使得易于交换产品系列，一个具体的工程类在一个应用中仅出现一次，即在它初始化的时候，
* 这使得改变一个应用的具体的工厂变得容易，只需要改变具体工厂即可使用不同的产品配置，
* 因为一个抽象工厂创建了一个完整系列，属于整个产品系列会立刻改变。（即产品族的约束为非公开状态）
* 3、它有利于产品的一致性，当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，
* 因为这在实际应用中经常遇到，而抽象工厂则非常容易实现这点。
*
* 抽象工厂模式缺点：1、难以支持新种类的产品。难以扩展抽象工厂以生产新种类的产品。这是因为抽象工厂几口确定了可以被创建的产品集合，
* 支持新种类的产品就需要扩展该工厂接口，这将涉及抽象工厂类及其所有子类的改变。
*/
/// <summary>
/// 产品A的抽象
/// </summary>
public abstract class AbstractProductA
{
/// <summary>
/// 产品A的抽象业务逻辑
/// </summary>
public abstract void BDoSomething();
}
/// <summary>
/// 产品B的抽象
/// </summary>
public abstract class AbstractProductB
{
/// <summary>
/// 产品B的抽象业务逻辑
/// </summary>
public abstract void BDoSomething();
}
/// <summary>
/// A类具体产品A1
/// </summary>
public class ProductA1 : AbstractProductA
{
/// <summary>
/// 具体产品A1的业务逻辑
/// </summary>
public override void BDoSomething()
{
//A1业务逻辑的实现
}
}
/// <summary>
/// A类具体产品A2
/// </summary>
public class ProductA2 : AbstractProductA
{
/// <summary>
/// 产品A2的业务逻辑
/// </summary>
public override void BDoSomething()
{
//A2业务逻辑的实现
}
}
/// <summary>
/// B类的具体产品B1
/// </summary>
public class ProductB1 : AbstractProductB
{
public override void BDoSomething()
{
//B1产品的业务逻辑
}
}
/// <summary>
/// B类的具体产品B2
/// </summary>
public class ProductB2 : AbstractProductB
{
public override void BDoSomething()
{
//B2产品的业务逻辑
}
}
/// <summary>
/// 产品家族的具体创建抽象
/// </summary>
public abstract class AbstactFactory
{
/// <summary>
/// 创建A类产品的抽象逻辑
/// </summary>
/// <returns></returns>
public abstract AbstractProductA CreateProdcutA();
/// <summary>
/// 创建B类产品的抽象逻辑
/// </summary>
/// <returns></returns>
public abstract AbstractProductB CreateProdcutB();
}
/// <summary>
/// 创建第一族产品的具体工厂类
/// </summary>
public class ProdcutFactory1 : AbstactFactory
{
/// <summary>
/// 创建产品A1的实现
/// </summary>
/// <returns></returns>
public override ProductA1 CreateProdcutA()
{
return new ProductA1();
}
/// <summary>
/// 创建产品B1的实现
/// </summary>
/// <returns></returns>
public override ProductB1 CreateProdcutB()
{
return new ProductB1();
}
}
/// <summary>
/// 创建第二产品族的具体工厂
/// </summary>
public class ProdcutFactory2 : AbstactFactory
{
/// <summary>
/// 创建产品A2的实现
/// </summary>
/// <returns></returns>
public override ProductA2 CreateProdcutA()
{
return new ProductA2();
}
/// <summary>
/// 创建产品B2的实现
/// </summary>
/// <returns></returns>
public override ProductB2 CreateProdcutB()
{
return new ProductB2();
}
}
/// <summary>
/// 客户端调用类
/// </summary>
public class AppClient
{
public static void Main(string []args)
{
AbstactFactory factroy1=new ProdcutFactory1();
AbstractProductA a1 = factroy1.CreateProdcutA();
AbstractProductB b1 = factroy1.CreateProdcutB();
a1.BDoSomething();//调用A1的方法
b1.BDoSomething();//调用B的方法
AbstactFactory factory2 = new ProdcutFactory2();
AbstractProductA a2 = factory2.CreateProdcutA();
AbstractProductB b2 = factory2.CreateProdcutB();
a2.BDoSomething(); //调用A2的方法
b2.BDoSomething(); //调用B2的方法
}
}
}
