设计模式之： abstract factory

namespace DesignPattern
{
    abstract class Document
    {
        abstract public void Dump();
    }
    abstract class WorkSpace
    {
        abstract public void Dump();
    }
    abstract class View
    {
        abstract public void Dump();
    }
    abstract class Factory
    {
        abstract public Document CreateDocument();
        abstract public WorkSpace CreateWorkSpace();
        abstract public View CreateView();
    }
    abstract class Application
    {
        protected Document doc;
        protected WorkSpace workspace;
        protected View view;
        abstract public void Dump();
        protected void DumpImpl()//真正的Dump实现的地方
        {
            if(doc != null) doc.Dump();
            if(workspace != null ) workspace.Dump();
            if(view != null ) view.Dump();
        }
    }
    //上面的都是抽象类
    class MyDocument:Document
    {
        public override void Dump()
        {
            Console.WriteLine("MyDocument:Dump");
        }
    }
    class MyWorkSpace : WorkSpace
    {
        public override void Dump()
        {
            Console.WriteLine("MyWorkSpace:Dump");
        }
    }
    class MyView : View
    {
        public override void Dump()
        {
            Console.WriteLine("MyView:Dump");
        }
    }
    class MyFactory:Factory
    {
        public override Document CreateDocument()
        {
             return new MyDocument();
        }

        public override WorkSpace CreateWorkSpace()
        {
             return new MyWorkSpace();
        }

        public override View CreateView()
        {
             return new MyView();
        }
    }
    class MyApplication:Application
    {
        readonly MyFactory factory = new MyFactory();
        public MyApplication()
        {
            this.doc = factory.CreateDocument();
            this.workspace = factory.CreateWorkSpace();
            this.view = factory.CreateView();
        }
        public override void Dump()
        {
            this.DumpImpl();
        }
    }

    public class Client
    {
        public static int Main(string[] args)
        {
            MyApplication myApplication = new MyApplication();

            myApplication.Dump();

            Console.ReadLine();

            return 0;
        }
    }
}
    

个人总结如下：

Abstract Factory模式适用于如下情况：

（1）某个类MyApplication，有多个成员变量doc，workspace，view

（2）这个类中的方法Dump，要通过调用成员变量的方法Dump来实现。

有一点需要注意的地方：

真正的方法逻辑和实现已经在上面的抽象层显现了，这是我认为很高明的地方。Application里面的DumpImpl（）是真正实现方法的地方。个人确实自愧不如。