Mingbo

概述

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。

意图

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

逻辑模型：

物理模型：

相关代码：

/*
 * File: facilityFactory.cs
 * Description: 这个类包含整个系列所需的所有抽象类
 * **/

namespace AbstractFactory
{
    abstract class road
    {
        public abstract void playOnTheRoad();
    }

    abstract class house
    {
        public abstract void playInTheHouse();
    }

    abstract class facilityFactory
    {
        public abstract road creatRoad();
        public abstract house creatHouse();
    }
}
/*
 * File: classicFacilityFactory.cs
 * Description: 这个类是facilityFactory的具体实现
 * **/
using System;

namespace AbstractFactory
{
    class classicRoad : road
    {
        public override void playOnTheRoad()
        {
            Console.WriteLine("playOnTheClassicRoad");
        }
    }

    class classicHouse : house
    {
        public override void playInTheHouse()
        {
            Console.WriteLine("playInTheClassicHouse");
        }
    }

    class classicFacilityFactory : facilityFactory
    {
        public override house creatHouse()
        {
            return new classicHouse();
        }

        public override road creatRoad()
        {
            return new classicRoad();
        }
    }
}
/*
 * File: modernFacilityFactory.cs
 * Description: 这个类是facilityFactory的具体实现
 * **/
using System;

namespace AbstractFactory
{
    class modernRoad:road
    {
        public override void playOnTheRoad()
        {
            Console.WriteLine("playOnTheModernRoad");
        }
    }

    class modernHouse : house
    {
        public override void playInTheHouse()
        {
            Console.WriteLine("playInTheModernHouse");
        }
    }

    class modernFacilityFactory:facilityFactory
    {
        public override house creatHouse()
        {
            return new modernHouse();
        }

        public override road creatRoad()
        {
            return new modernRoad();
        }
    }
}
/*
 * File: gameManager.cs
 * Description: 这个类是客户端程序，完全的使用抽象类（接口）
 * **/
namespace AbstractFactory
{
    class gameManager
    {
        facilityFactory facilityFactory ;
        road road;
        house house;
        private static gameManager manager = null;

        public static gameManager GetInstance(facilityFactory facilityFactory)
        {
            if (manager == null)
            {
                manager=new gameManager(facilityFactory);
            }
            return manager;
        }

        private gameManager(facilityFactory facilityFactory)
        {
            this.facilityFactory = facilityFactory;
        }

        public void init()
        {
            house = facilityFactory.creatHouse();
            road = facilityFactory.creatRoad();
        }

        public void play()
        {
            this.house.playInTheHouse();
            this.road.playOnTheRoad();
        }
    }
}
using System.Configuration;
using System.Reflection;

namespace AbstractFactory
{
    class Program
    {
        //将变化封装到配置文件里
        static void Main(string[] args)
        {
            //从配置文件中读取相关系列参数
            string factoryName = System.Configuration.ConfigurationManager.AppSettings["FacilityFactory"];
            //利用反射机制，动态加载系列参数
            gameManager manager = gameManager.GetInstance((facilityFactory)Assembly.Load("AbstractFactory").CreateInstance(factoryName));
            manager.init();
            manager.play();
            System.Console.ReadLine();
        }
    }
}

下面是配置文件

总结：

抽象工厂提供了一个创建一系列相关或相互依赖对象的接口，因此使用抽象工厂的前提是有“多系列对象”变化的需求。除此之外，我们还应看到面向对象编程的精华：面向接口编程。