模式设计c#－－创建型－－AbstractFactory

模式设计c#－－创建型－－AbstractFactory

名称	Abstract Factory
结构
意图	提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性	一个系统要独立于它的产品的创建、组合和表示时。 一个系统要由多个产品系列中的一个来配置时。 当你要强调一系列相关的产品对象的设计以便进行联合使用时。 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

      
Code Example
       

namespace  AbstractFactory_DesignPattern
{
    using System;

    // These classes could be part of a framework,
    // which we will call DP
    // ===========================================
    
    abstract class DPDocument 
    {
        abstract public void Dump();        
    }

    abstract class DPWorkspace
    {
        abstract public void Dump();
    }
    
    abstract class DPView 
    {
        abstract public void Dump();
    }    
    
    abstract class DPFactory 
    {
        abstract public DPDocument CreateDocument();
        abstract public DPView CreateView();
        abstract public DPWorkspace CreateWorkspace();
    }

    abstract class DPApplication 
    {
        protected DPDocument doc;
        protected DPWorkspace workspace;
        protected DPView view;
        
        public void ConstructObjects(DPFactory factory)
        {
            // Create objects as needed
            doc = factory.CreateDocument();
            workspace = factory.CreateWorkspace();
            view = factory.CreateView();
        }        
        
        abstract public void Dump();

        public void DumpState()
        {
            if (doc != null) doc.Dump();
            if (workspace != null) workspace.Dump();
            if (view != null) view.Dump();
        }
    }

    // These classes could be part of an application 
    class MyApplication : DPApplication 
    {
        MyFactory myFactory = new MyFactory();

        override public void Dump()
        {
            Console.WriteLine("MyApplication exists");
        }

        public void CreateFamily()
        {
            MyFactory myFactory = new MyFactory();
            ConstructObjects(myFactory);            
        }
    }    

    class MyDocument : DPDocument 
    {
        public MyDocument()
        {
                Console.WriteLine("in MyDocument constructor");            
        }
        
        override public void Dump()
        {
            Console.WriteLine("MyDocument exists");
        }
    }

    class MyWorkspace : DPWorkspace 
    {
        override public void Dump()
        {
            Console.WriteLine("MyWorkspace exists");
        }
    }

    class MyView : DPView 
    {
        override public void Dump()
        {
            Console.WriteLine("MyView exists");
        }
    }

    class MyFactory : DPFactory 
    {
        override public DPDocument CreateDocument()
        {
            return new MyDocument();
        }
        override public DPWorkspace CreateWorkspace()
        {
            return new MyWorkspace();
        }        
        override public DPView CreateView()
        {
            return new MyView();
        }
    }

    /**//// <summary>
    ///    Summary description for Client.
    /// </summary>
    public class Client
    {
        public static int Main(string[] args)
        {
            MyApplication myApplication = new MyApplication();

            myApplication.CreateFamily();

            myApplication.DumpState();
            
            return 0;
        }
    }
}

//  Abstract Factory pattern -- Structural example  


using  System;

namespace  DoFactory.GangOfFour.Abstract.Structural
{
  // 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" - the interaction environment of the products 

  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);
    }
  }
}
 

Output

ProductB1 interacts with ProductA1 ProductB2 interacts with ProductA2