C++ Programmer's Cookbook

{C++ 基础} {C++ 高级} {C#界面，C++核心算法} {设计模式} {C#基础}

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

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

posted on 2006-01-03 14:43 梦在天涯 阅读(1043) 评论(3)  编辑 收藏 引用 所属分类: Design pattern

评论

# re: 模式设计c#－－创建型－－AbstractFactory 2006-04-24 10:10 梦在天涯

definition
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
  回复  更多评论   

# re: 模式设计c#－－创建型－－AbstractFactory 2006-04-24 10:34 梦在天涯

提供一个创建一组相关或无关对象的接口,而没有指定具体的类.  回复  更多评论   

# re: 模式设计c#－－创建型－－AbstractFactory 2006-04-24 10:38 梦在天涯

实际上，有些时候两者是结合使用的。我见过BuilderFactory。在Java的DOM模型中就使用了BuilderFactory。

Java 环境中，解析文件是一个三步过程：

1、创建 DocumentBuilderFactory。 DocumentBuilderFactory 对象创建 DocumentBuilder。
2、创建 DocumentBuilder。 DocumentBuilder 执行实际的解析以创建 Document 对象。
3、解析文件以创建 Document 对象。

关键代码如下：

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import org.w3c.dom.Document;

public class OrderProcessor {
public static void main (String args[]) {
File docFile = new File("orders.xml");
Document doc = null;
try {

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
doc = db.parse(docFile);

} catch (Exception e) {
System.out.print("Problem parsing the file: "+e.getMessage());
}
}
}

很有创意的！   回复  更多评论   


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


公告

EMail：itech001#126.com

导航

统计

  • 随笔 - 461
  • 文章 - 4
  • 评论 - 746
  • 引用 - 0

常用链接

随笔分类

随笔档案

收藏夹

Blogs

c#(csharp)

C++(cpp)

Enlish

Forums(bbs)

My self

Often go

Useful Webs

Xml/Uml/html

搜索

  •  

积分与排名

  • 积分 - 1795849
  • 排名 - 5

最新评论

阅读排行榜