阅读源码学设计模式-单例模式

640?wx_fmt=png

有些编码套路是公认的，大家都参照其编写符合可观赏性的代码，那就是设计模式

现在.NETcore 默认提供了DI功能，那我想设计一个全局的引擎类，进行注入服务、解析服务、配置中间件。并且要求该引擎类全局唯一，其他地方不能进行实例化。那单例模式就派上用场了。单例模式官方定义：

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类成为单例类，它提供全局访问的方法。

伪代码实现需求

 public class AAEngine    {        private static AAEngine aAEngine = null;        private AAEngine() { }        //获取实例        public static AAEngine GetInstance()        {            if (aAEngine == null)            {                aAEngine = new AAEngine();            }            return aAEngine;        }        //添加服务到容器        public  void ConfigureService()        {            Console.WriteLine("添加服务到容器");        }        //添加中间件到请求管道        public  void ConfigureRequestPipeline()        {            Console.WriteLine("添加中间件到请求管道");        }        //解析服务        public  void Resolve<T>() where T : class        {            Console.WriteLine("解析服务");        }
    }

在Main函数中调用

//单例模式        static void runSingleton()        {            var aAEngine = AAEngine.GetInstance();            aAEngine.ConfigureService();            aAEngine.ConfigureRequestPipeline();            Console.WriteLine("Oh yeah 单例模式! ");        }

输出

640?wx_fmt=png

小结：从实例代码中我们看到构造函数设置了级别为private，这样可以防止外部进行new实例化，外部可以通过GetInstance方法获取实例对象。实例代码其实是有点瑕疵的在多线程的情况下，会违背单例的初衷，我们下面进行如何解决这个问题。

突然脑海中闪现出曾经的面试场景，饿汉式单例和懒汉式单例，或许对问题有所有帮助；

饿汉式单例

饿汉试单例是在类加载的时候就已经创建了对象。代码如下

public class AAEngine1    {        private static AAEngine1 aAEngine = new AAEngine1();        private AAEngine1() { }        //获取实例        public static AAEngine1 GetInstance()        {            return aAEngine;        }
        //添加服务到容器        public void ConfigureService()        {            Console.WriteLine("添加服务到容器");        }        //添加中间件到请求管道        public void ConfigureRequestPipeline()        {            Console.WriteLine("添加中间件到请求管道");        }        //解析服务        public void Resolve<T>() where T : class        {            Console.WriteLine("解析服务");        }    }

小结：在类被加载时，静态变量aAEngine会被初始化，AAEngine1类的唯一实例将会创建，则多线程并发的场景下，也可确保单例对象的唯一性；那什么是懒汉式单例呢？其实最上面的AAEngine就是懒汉式单例，在多线程并发的场景下懒汉式单例有问题，如何解决 答案是通过锁的方式。

懒汉式单例+线程锁

懒汉式单例有延迟Lazy的思想，只有在需要的时候才去加载实例。在多线程并发的场景下我们使用双重检查锁定（Double-Check Locking）。完成代码如下：

private static AAEngine aAEngine = null;        private static object lockObj=new object();        private AAEngine() { }        //获取实例        public static AAEngine GetInstance()        {            //第一重验证            if (aAEngine == null)            {                lock (lockObj)                {                    //第二重验证                    if (aAEngine==null)                    {                        aAEngine = new AAEngine();                    }                }            }            return aAEngine;        }

单例模式在开源Nop项目中实践

为了配合你没有阅读过Nop项目源码，我会把涉及到单例的几个类源码贴出来。主要设计到3个类Singleton、IEngine、EngineContext。

Singleton类

640?wx_fmt=gif

 public class Singleton<T> : BaseSingleton    {        private static T instance;
        /// <summary>        /// The singleton instance for the specified type T. Only one instance (at the time) of this object for each type of T.        /// </summary>        public static T Instance        {            get => instance;            set            {                instance = value;                AllSingletons[typeof(T)] = value;            }        }    }

IEngine类

public interface IEngine    {        /// <summary>        /// 添加配置服务 Add and configure services        /// </summary>        /// <param name="services">Collection of service descriptors</param>        /// <param name="configuration">Configuration of the application</param>        /// <param name="nopConfig">Nop configuration parameters</param>        /// <returns>Service provider</returns>        IServiceProvider ConfigureServices(IServiceCollection services, IConfiguration configuration, NopConfig nopConfig);
        /// <summary>        /// 配置请求管道 Configure HTTP request pipeline        /// </summary>        /// <param name="application">Builder for configuring an application's request pipeline</param>        void ConfigureRequestPipeline(IApplicationBuilder application);
        /// <summary>        /// 解析服务 Resolve dependency        /// </summary>        /// <typeparam name="T">Type of resolved service</typeparam>        /// <returns>Resolved service</returns>        T Resolve<T>() where T : class;
        /// <summary>        /// 解析服务 Resolve dependency        /// </summary>        /// <param name="type">Type of resolved service</param>        /// <returns>Resolved service</returns>        object Resolve(Type type);
        /// <summary>        ///  解析所有服务Resolve dependencies        /// </summary>        /// <typeparam name="T">Type of resolved services</typeparam>        /// <returns>Collection of resolved services</returns>        IEnumerable<T> ResolveAll<T>();
        /// <summary>        /// Resolve unregistered service        /// </summary>        /// <param name="type">Type of service</param>        /// <returns>Resolved service</returns>        object ResolveUnregistered(Type type);    }

EngineContext 引擎上下文类

 #region Methods
        /// <summary>        /// Create a static instance of the Nop engine.        /// </summary>        [MethodImpl(MethodImplOptions.Synchronized)]        public static IEngine Create()        {            //create NopEngine as engine            return Singleton<IEngine>.Instance ?? (Singleton<IEngine>.Instance = new NopEngine());        }
        /// <summary>        /// Sets the static engine instance to the supplied engine. Use this method to supply your own engine implementation.        /// </summary>        /// <param name="engine">The engine to use.</param>        /// <remarks>Only use this method if you know what you're doing.</remarks>        public static void Replace(IEngine engine)        {            Singleton<IEngine>.Instance = engine;        }                #endregion
        #region Properties
        /// <summary>        /// Gets the singleton Nop engine used to access Nop services.        /// </summary>        public static IEngine Current        {            get            {                if (Singleton<IEngine>.Instance == null)                {                    Create();                }
                return Singleton<IEngine>.Instance;            }        }
        #endregion    }

从nop的源码中我们发现，他使用的懒汉式单例（含双重检查锁定），外部访问IEngine实例是通过EngineContext上下文来访问的。在创建IEngine实例方法create（）时，使用时的 [MethodImpl(MethodImplOptions.Synchronized)]特性，表示create方法只能由一个线程执行，类似lock锁。

如何使用，代码如下

 //create engine and configure service provider var engine = EngineContext.Create(); var serviceProvider = engine.ConfigureServices(services, configuration, nopConfig);  。。。。。。。。。。。。 EngineContext.Current.Resolve<IScheduleTaskService>();

nop封装的优秀的代码，也收录到我的开源项目中了，喜欢可以star下 https://github.com/ChengLab/AAFrameWork

640?wx_fmt=jpeg