时间：2010-03-27
人物：华中师范大学-09级信技系研究生
地点：木兰天池
活动：起早床，坐长途汽车，爬山然后下山，最后继续坐长途汽车

木兰天池风景区位于黄陂区北部的石门山，距武汉市中心仅55公里，距天河机场仅45公里。整个景区占地面积4800亩，分为风景游览区和休闲度假区。其主峰海拔520.6公尺，属大别山南麓一脉，这里沟壑纵横，林木茂盛，一年四季流水不断，呈现的是一种山水交融的湿地生态。景区年平均气温介于15-22℃之间，七月份平均气温25.8℃，年降水量平均2000毫米左右。

来木兰天池，已经是第二次了。虽然少了一些新鲜感，但是与不同的人前去也别有乐趣。景区，真的没啥风景可言，所以也没拍到啥好看的景色。由于我的Flickr 流量都贡献给了上次的桃李园 ，这一次就只能直接传到空间里了。图片链接在这里.

哎，那天，本来被小弟喊去武大看樱花的。结果，早上跑去电脑城买配件的时候，忘记带手机，所以没联系上。下午一个人跑去学校的时候，在校车上看到桃李园的花开的正红，就把相机掏出来拍了一拍。

概述

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（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();
        }
    }
}

下面是配置文件

总结：

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

最近那个项目的工作停滞了。我深切的感受到，基础知识不扎实带来的苦痛。反正在没有新的安排之前，我会继续自学。然后…不知道有什么然后。今天开始继续学习、复习设计模式。

設計模式（design pattern）這個術語是在1990年代，由Erich Gamma等人，從建築設計領域引入到計算機科學裡去的。是對軟體設計中普遍存在（反覆出現）的各種問題，所提出的解決方案。設計模式並不直接用來完成程式碼的編寫，而是描述在各種不同情況下，要怎麼解決問題的一種方案。物件導向設計模式通常以類別或物件來描述其中的關係和相互作用，但不涉及用來完成應用程式的特定類別或物件。設計模式主要是使不穩定的依賴於相對穩定、具體依賴於相對抽象，避免會引起麻煩的緊耦合，以增強軟體設計面對並適應變化的能力。

动机

意图

保证一个类仅有一个实例，并提供一个该实例的全局访问点。

代码

    ///
    /// 利用.net 的内部机制，较为简洁的实现了Singlton
    /// 优点：支持多线程
    /// 缺点：初始化时，不能传参（相关参数可以通过其他方式调用，如属性）
    ///
    class Singlton
    {
        private Singlton() { }

        public static readonly Singlton Instance = new Singlton();
    }

    ///
    /// 实际上，同上述实现方式一致。
    /// 在调用Instance 之前Singlton2 的静态函数就已经执行，并只执行一次。
    ///
    class Singlton2
    {
        public static readonly Singlton2 Instance;

        static Singlton2()
        {
            Instance = new Singlton2();
        }

        private Singlton2()
        { }
    }
    ///
    /// 最常见的Singlton 实现方式
    ///
    class Singlton3
    {
        public static Singlton3 Instance;

        private Singlton3() { }

        public Singlton3 getInstance
        {
            get
            {
                if (Instance == null)
                {
                    Instance = new Singlton3();
                }
                return Instance;
            }
        }
    }
    ///
    /// 用双重锁支持多线程的实现方式
    ///
    class Singlton4
    {
        private static Singlton4 Instance;

        private static object locker=new object(); 

        private Singlton4() { }

        public Singlton4 getInstance
        {
            get
            {
                if (Instance == null)
                {
                    lock (locker)
                    {
                        if (Instance == null)
                        {
                            Instance = new Singlton4();
                        }
                    }
                }
                return Instance;
            }
        }
    }