单例模式是是常用经典十几种设计模式中最简单的。.NET中单例模式的实现也有很多种方式。下面我来介绍一下NopCommerce中单例模式实现。
我之前的文章就分析了一下nop中EngineContext的实现。EngineContext是把一个Web请求用Nop的EngineContext引擎上下文封装。里面提供了一个IEngine的单例对象的访问方式。
下面就是EngineContext的源码：
一、EngineContext
using System.Configuration;
using System.Runtime.CompilerServices;
using Nop.Core.Configuration;
namespace Nop.Core.Infrastructure
{
/// <summary>
///Provides access to the singleton instance of the Nop engine.
///提供了访问单例实例Nop引擎
/// </summary>
public class EngineContext
{
#region Methods
/// <summary>
/// Initializes a static instance of the Nop factory.
/// 初始化静态Nop工厂的实例
/// </summary>
/// <param name="forceRecreate">创建一个新工厂实例,尽管工厂已经被初始化</param>
[MethodImpl(MethodImplOptions.Synchronized)]
public static IEngine Initialize(bool forceRecreate)
{
if (Singleton<IEngine>.Instance == null || forceRecreate)
{
Singleton<IEngine>.Instance = new NopEngine();
var config = ConfigurationManager.GetSection("NopConfig") as NopConfig;
Singleton<IEngine>.Instance.Initialize(config);
}
return Singleton<IEngine>.Instance;
}
/// <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)
{
Initialize(false);
}
return Singleton<IEngine>.Instance;
}
}
#endregion
}
}
上面Initialize方法使用[MethodImpl(MethodImplOptions.Synchronized)]声明，就保证只能有一个线程访问，因为.NET的Web程序无论是WebForm还是mvc都在服务端都是多线程的。这样就标记只能有一个线程调用Initialize方法，也就保证了实例对象IEngine的在内存中只有一份。然后把单例实例对象的存储到类Singleton中。Singleton就像是一个对象容器，可以把许多单例实例对象存储在里面。
下面我们来看看实例Singleton的实现思路。
二、Singleton
using System;
using System.Collections.Generic;
namespace Nop.Core.Infrastructure
{
/// <summary>
/// A statically compiled "singleton" used to store objects throughout the
/// lifetime of the app domain. Not so much singleton in the pattern's
/// sense of the word as a standardized way to store single instances.
/// </summary>
/// <typeparam name="T">The type of object to store.</typeparam>
/// <remarks>Access to the instance is not synchrnoized.</remarks>
public class Singleton<T> : Singleton
{
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 { return instance; }
set
{
instance = value;
AllSingletons[typeof(T)] = value;
}
}
}
/// <summary>
/// Provides a singleton list for a certain type.
/// </summary>
/// <typeparam name="T">The type of list to store.</typeparam>
public class SingletonList<T> : Singleton<IList<T>>
{
static SingletonList()
{
Singleton<IList<T>>.Instance = new List<T>();
}
/// <summary>The singleton instance for the specified type T. Only one instance (at the time) of this list for each type of T.</summary>
public new static IList<T> Instance
{
get { return Singleton<IList<T>>.Instance; }
}
}
/// <summary>
/// Provides a singleton dictionary for a certain key and vlaue type.
/// </summary>
/// <typeparam name="TKey">The type of key.</typeparam>
/// <typeparam name="TValue">The type of value.</typeparam>
public class SingletonDictionary<TKey, TValue> : Singleton<IDictionary<TKey, TValue>>
{
static SingletonDictionary()
{
Singleton<Dictionary<TKey, TValue>>.Instance = new Dictionary<TKey, TValue>();
}
/// <summary>The singleton instance for the specified type T. Only one instance (at the time) of this dictionary for each type of T.</summary>
public new static IDictionary<TKey, TValue> Instance
{
get { return Singleton<Dictionary<TKey, TValue>>.Instance; }
}
}
/// <summary>
/// Provides access to all "singletons" stored by <see cref="Singleton{T}"/>.
/// </summary>
public class Singleton
{
static Singleton()
{
allSingletons = new Dictionary<Type, object>();
}
static readonly IDictionary<Type, object> allSingletons;
/// <summary>Dictionary of type to singleton instances.</summary>
public static IDictionary<Type, object> AllSingletons
{
get { return allSingletons; }
}
}
}
Singleton类里面用一个Dictionary<Type, object>()集合来存储所有的单例对象。基于Singleton类创建一些泛型类Singleton<T>，Singleton<IList<T>>，SingletonList<T>，Singleton<IDictionary<TKey, TValue>>和SingletonDictionary<TKey, TValue>。