用C#来说明设计模式(二）抽象工厂

创建型的设计模式中的(Abstract Pattern)抽象工厂模式

定义(difinition):
Provide an interface for creating families of related or dependent objects without specifying their concrete classes .


提供一个接口可以创建一系列没有实现类的,相关联的对象.
说明：
AbstractFactory 定义一个接口去生成一个抽象的产品
declare an interface for operations that create abstract product
ConcreteFactoty 实现操作产生产品对象
Implement operations to create concrete product object .
AbstractProduct 为一个类型的产品定义一个接口
Declare an interface for a type of product object
Product 工厂实现的一个具体的产品
implements abstract product  interface
defines a product to be created by the corresponding concrete factory .
Client 使用工厂和产品的抽象的接口
User interface  declared by AbstractFactory and AbstractProduct Classes.

实例：
在一个（AnimalWorld) 动物的世界中（Client) ,在有陆地的地方(AbstractFactory, 比如：ContinentFactory),分为各个大洲,如：美洲（ConcreteFactory,America Factory），非洲 (Africa Factory) .就有很多的动物，分为食草动物(Herbivore Abstract Products)和食肉动物(CarniVore Abstract Products) ，在每个大洲又有不同的食草和食肉动物。具体的有Lion （Product)使在非洲的食肉动物。

下面是实例代码:
1.UML代码

using System;

// "AbstractFactory"

abstract class AbstractFactory
{
  // Methods
  abstract public AbstractProductA CreateProductA();
  abstract public AbstractProductB CreateProductB();
}

// "ConcreteFactory1"

class ConcreteFactory1 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA1();
  }
  override public AbstractProductB CreateProductB()
  {
    return new ProductB1();
  }
}

// "ConcreteFactory2"

class ConcreteFactory2 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA2();
  }

  override public AbstractProductB CreateProductB()
  {
    return new ProductB2();
  }
}

// "AbstractProductA"

abstract class AbstractProductA
{
}

// "AbstractProductB"

abstract class AbstractProductB
{
  // Methods
  abstract public void Interact( AbstractProductA a );
}

// "ProductA1"
 
class ProductA1 : AbstractProductA
{
}

// "ProductB1"

class ProductB1 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "ProductA2"

class ProductA2 : AbstractProductA
{
}

// "ProductB2"

class ProductB2 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "Client" - the interaction environment of the products

class Environment
{
  // Fields
  private AbstractProductA AbstractProductA;
  private AbstractProductB AbstractProductB;

  // Constructors
  public Environment( AbstractFactory factory )
  {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }
 
  // Methods
  public void Run()
  {
    AbstractProductB.Interact( AbstractProductA );
  }
}

/// <summary>
/// ClientApp test environment
/// </summary>
class ClientApp
{
  public static void Main(string[] args)
  {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
}

2.RealWorld代码


using System;

// "AbstractFactory"

abstract class ContinentFactory
{
  // Methods
  abstract public Herbivore CreateHerbivore();
  abstract public Carnivore CreateCarnivore();
}

// "ConcreteFactory1"

class AfricaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  {
    return new Wildebeest();
  }
  override public Carnivore CreateCarnivore()
  {
    return new Lion();
  }
}

// "ConcreteFactory2"

class AmericaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  {
    return new Bison();
  }

  override public Carnivore CreateCarnivore()
  {
    return new Wolf();
  }
}

// "AbstractProductA"

abstract class Herbivore
{
}

// "AbstractProductB"

abstract class Carnivore
{
  // Methods
  abstract public void Eat( Herbivore h );
}

// "ProductA1"

class Wildebeest : Herbivore
{
}

// "ProductB1"

class Lion : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
}

// "ProductA2"

class Bison : Herbivore
{
}

// "ProductB2"

class Wolf : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
}

// "Client"

class AnimalWorld
{
  // Fields
  private Herbivore herbivore;
  private Carnivore carnivore;

  // Constructors
  public AnimalWorld( ContinentFactory factory )
  {
    carnivore = factory.CreateCarnivore();
    herbivore = factory.CreateHerbivore();
  }

  // Methods
  public void RunFoodChain()
  {
    carnivore.Eat( herbivore );
  }
}

/// <summary>
///  GameApp test class
/// </summary>
class GameApp
{
  public static void Main( string[] args )
  {
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world = new AnimalWorld( america );
    world.RunFoodChain();
  }
}