重构：将单例模式从业务类中完全解耦

先来看看Singleton的用例图：

在一个实际的老项目中，有很多的业务类，也不知道当时如何设计的，这些业务类均被设计成了Singleton模式。

项目中这些业务类结构如下：

而每个业务类的设计均为单例，诸如：

public class SearchHelper
    {
        private object obj = new object();
        private static SearchHelper search;
        private SearchHelper(){}
        public static SearchHelper Instance
        {
            get
            {
                if (search == null)
                {
                    lock (obj)
                    {
                        if (search == null)
                            search = new SearchHelper();
                    }
                }
                return search;
            }
        }
        public string GetSearch()
        {
            return "Path";
        }
    }

这种设计初初一看，就不是很顺眼。

这种业务类和单例本身强结合的模式，实际应用中，还真带来了一些麻烦，比如这个SearchHelper, 我有时候需要对某些方法获取更新某实体后的值，因其单例类模式，直接就无法得到其值，只好绕弯路。

于是重构这个模块，已经是摆在面前。 当然也可以不去重构，让代码继续乱下去，乱下去，乱下去，直到死亡 ：-）

 

经过一番考虑，首先想到的是将这些业务类和单例这个模式强结合的模式分离， 分离后让单例不再强奸这些业务类。

 

于是，就有了下文：

第一步：将这些业务类的单例去除，出除后，代码结构如下：

public class SearchHelper
 {   
　　private SearchHelper(){}
      public string GetPath()
      {
          return "Path";
      }
 }

同理，去除其他所有的业务类的单例。
PathHelper：

public class PathHelper
{
　　private PathHelper(){}
   public string GetPath()
   {
       return "Path";
   }
}

MapHelper： 

 public class MapHelper
 {
　 private MapHelper(){}
   public string GetMap()
   {
      return "Map";
   }
 }

 

第二步：定义个单例专用类，定义一个泛型类，并利用反射特性使其能够动态按需创建单例

 public class Singleton<T> where T : class
    {

        static Mutex mutex = new Mutex();
        static T instance;

        private Singleton() { }

        public static T UniqueInstance
        {
            get
            {
                mutex.WaitOne();        // enter protected area
                if (instance == null)
                {
                    try
                    {
                        instance = SingletonCreator.instance;
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }

                }
                mutex.ReleaseMutex();   // exit protected area

                return instance;
            }
        }

        class SingletonCreator
        {
            static SingletonCreator() { }
            // Private object instantiated with private constructor
            internal static readonly T instance = CreateNewInstance();

            private static T CreateNewInstance()
            {
                //Get the current assembly object
                Assembly assembly = Assembly.GetExecutingAssembly();

                // Retrieve assembly types
                Type[] types = assembly.GetTypes();
                foreach (Type typeName in types)
                {
                    Module typeMod = assembly.GetModule(typeName.ToString());
                    if (typeof(T).IsAssignableFrom(typeName) && (typeName.IsClass))
                    {
                        // Create and return an instance of the appropriate model object
                        return Activator.CreateInstance(typeName) as T;
                    }
                }
                throw new Exception("New instance not found!");
            }
        }
    }

第三步： 定义一个Dispatcher类，用以得到泛型类的单例。

 public class Dispatcher
    {
        public static T BuildObject<T>() where T : class
        {
            return Singleton<T>.UniqueInstance;
        }
    }

第四步： 定义一个Facades类，用以得到想要的具体的某业务类的单例。

 public class Facades  
    {
        private static SearchHelper searchHelper;
        private static  MapHelper mapHelper;
        private static  PathHelper pathHelper;

        public SearchHelper SearchHelper
        {
            get { return searchHelper; }
        }

        public MapHelper MapHelper
        {
            get { return mapHelper; }
        }

        public PathHelper PathHelper
        {
            get { return pathHelper; }
        }
        public Facades()
        {
            searchHelper = Dispatcher.BuildObject<SearchHelper>();
            mapHelper = Dispatcher.BuildObject<MapHelper>();
            pathHelper = Dispatcher.BuildObject<PathHelper>();
        }       
    }

 

好了，到此为止，已经将单例模式从业务类中完全解耦。

业务类就是业务来，单例就是单例，无需将单例强加在业务类上。重构后，其文件结构如下：