Le modèle fabrique abstraite(Abstract Factory Pattern)

using System;
{
// MainApp test application
class MainApp{
public static void Main(){
// Abstract factory #1
AbstractFactory factory1 = new ConcreteFactory1();
Client c1 = new Client(factory1);
c1.Run();
// Abstract factory #2
AbstractFactory factory2 = new ConcreteFactory2();
Client c2 = new Client(factory2);
c2.Run();
// Wait for user input
Console.Read();
}
}
// AbstractFactory
abstract class AbstractFactory{
public abstract AbstractProductA CreateProductA();
public abstract AbstractProductB CreateProductB();
}
// ConcreteFactory1
class ConcreteFactory1: AbstractFactory{
public override AbstractProductA CreateProductA(){
return new ProductA1();
}
public override AbstractProductB CreateProductB(){
return new ProductB1();
}
}
// ConcreteFactory2
class ConcreteFactory2: AbstractFactory{
public override AbstractProductA CreateProductA(){
return new ProductA2();
}
public override AbstractProductB CreateProductB(){
return new ProductB2();
}
}
// AbstractProductA
abstract class AbstractProductA{
}
// AbstractProductB
abstract class AbstractProductB{
public abstract void Interact(AbstractProductA a);
}
// ProductA1
class ProductA1: AbstractProductA{
}
// ProductB1
class ProductB1: AbstractProductB{
public override void Interact(AbstractProductA a){
Console.WriteLine(this.GetType().Name +
" interacts with " + a.GetType().Name);
}
}
// ProductA2
class ProductA2: AbstractProductA{
}
// ProductB2
class ProductB2: AbstractProductB{
public override void Interact(AbstractProductA a){
Console.WriteLine(this.GetType().Name +
" interacts with " + a.GetType().Name);
}
}
// Client
class Client{
private AbstractProductA AbstractProductA;
private AbstractProductB AbstractProductB;
// Constructor
public Client(AbstractFactory factory){
AbstractProductB = factory.CreateProductB();
AbstractProductA = factory.CreateProductA();
}
public void Run(){
AbstractProductB.Interact(AbstractProductA);
}
}
}

/**
* DemoLauncher class for the abstract factory pattern.
*/
public class DemoLauncher{
    public static void main( String arg[] ){
        AbstractFactory factory1 = new ConcreteFactory1();
        Client c1 = new Client(factory1);
        c1.run();
        AbstractFactory factory2 = new ConcreteFactory2();
        Client c2 = new Client(factory2);
        c2.run();
    }
}
/**
* Declares an interface for operations that create
* abstract product objects.
*/
public interface AbstractFactory{
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}
/**
* Implements the operations to create concrete product objects.
*/
public class ConcreteFactory1 implements AbstractFactory{
    public AbstractProductA createProductA() { return new ProductA1(); };
    public AbstractProductB createProductB() { return new ProductB1(); };
}
public class ConcreteFactory2 implements AbstractFactory{
    public AbstractProductA createProductA() { return new ProductA2(); };
    public AbstractProductB createProductB() { return new ProductB2(); };
}
/**
* Declares an interface for a type of product object.
*/
public interface AbstractProductA{
}
public interface AbstractProductB{
    public void interact(AbstractProductA a);
}
/**
* Defines a product object to be created by the corresponsing
* concrete factory. Implements the AbstractProduct interface.
*/
public class ProductA1 implements AbstractProductA{
}
public class ProductB1 implements AbstractProductB{
    public void interact(AbstractProductA a) {
    System.out.println(this.getClass().getName()+
        " interacts with "+ a.getClass().getName());
    }
}
public class ProductA2 implements AbstractProductA{
}
public class ProductB2 implements AbstractProductB{
    public void interact(AbstractProductA a) {
        System.out.println(this.getClass().getName()+
            " interacts with "+ a.getClass().getName());
    }
}
/**
* Client class for the abstract factory pattern.
*/
public class Client{
    private AbstractProductA productA;
    private AbstractProductB productB;
    public Client(AbstractFactory factory){
        productA = factory.createProductA();
        productB = factory.createProductB();
    }
    public void run(){
        productB.interact(productA);
    }
}