【NopCommerce源码架构学习-二】单例模式实现代码分析

单例模式是是常用经典十几种设计模式中最简单的。.NET中单例模式的实现也有很多种方式。下面我来介绍一下NopCommerce中单例模式实现。

我之前的文章就分析了一下nop中EngineContext的实现。EngineContext是把一个Web请求用Nop的EngineContext引擎上下文封装。里面提供了一个IEngine的单例对象的访问方式。

下面就是EngineContext的源码：

一、EngineContext

1 using System.Configuration;
2
3 using System.Runtime.CompilerServices;
4
5 using Nop.Core.Configuration;
6
7
8
9 namespace Nop.Core.Infrastructure
10
11 {
12
13     /// <summary>
14
15     ///Provides access to the singleton instance of the Nop engine.
16
17     ///提供了访问单例实例Nop引擎
18
19     /// </summary>
20
21     public class EngineContext
22
23     {
24
25         #region Methods
26
27
28
29         /// <summary>
30
31         /// Initializes a static instance of the Nop factory.
32
33         /// 初始化静态Nop工厂的实例
34
35         /// </summary>
36
37         /// <param name="forceRecreate">创建一个新工厂实例,尽管工厂已经被初始化</param>
38
39         [MethodImpl(MethodImplOptions.Synchronized)]
40
41         public static IEngine Initialize(bool forceRecreate)
42
43         {
44
45             if (Singleton<IEngine>.Instance == null || forceRecreate)
46
47             {
48
49                 Singleton<IEngine>.Instance = new NopEngine();
50
51
52
53                 var config = ConfigurationManager.GetSection("NopConfig") as NopConfig;
54
55                 Singleton<IEngine>.Instance.Initialize(config);
56
57             }
58
59             return Singleton<IEngine>.Instance;
60
61         }
62
63
64
65         /// <summary>
66
67         /// Sets the static engine instance to the supplied engine. Use this method to supply your own engine implementation.
68
69         /// 设置静态引擎实例提供的引擎,
70
71         /// </summary>
72
73         /// <param name="engine">The engine to use.</param>
74
75         /// <remarks>Only use this method if you know what you're doing.</remarks>
76
77         public static void Replace(IEngine engine)
78
79         {
80
81             Singleton<IEngine>.Instance = engine;
82
83         }
84
85
86
87         #endregion
88
89
90
91         #region Properties
92
93
94
95         /// <summary>
96
97         /// Gets the singleton Nop engine used to access Nop services.
98
99         /// </summary>
100
101         public static IEngine Current
102
103         {
104
105             get
106
107             {
108
109                 if (Singleton<IEngine>.Instance == null)
110
111                 {
112
113                     Initialize(false);
114
115                 }
116
117                 return Singleton<IEngine>.Instance;
118
119             }
120
121         }
122
123
124
125         #endregion
126
127     }
128
129 }

上面Initialize方法使用[MethodImpl(MethodImplOptions.Synchronized)]声明，就保证只能有一个线程访问，因为.NET的Web程序无论是WebForm还是mvc都在服务端都是多线程的。这样就标记只能有一个线程调用Initialize方法，也就保证了实例对象IEngine的在内存中只有一份。然后把单例实例对象的存储到类Singleton中。Singleton就像是一个对象容器，可以把许多单例实例对象存储在里面。

下面我们来看看实例Singleton的实现思路。

二、Singleton

1 using System;
2
3 using System.Collections.Generic;
4
5
6
7 namespace Nop.Core.Infrastructure
8
9 {
10
11     /// <summary>
12
13     /// A statically compiled "singleton" used to store objects throughout the
14
15     /// lifetime of the app domain. Not so much singleton in the pattern's
16
17     /// sense of the word as a standardized way to store single instances.
18
19     /// </summary>
20
21     /// <typeparam name="T">The type of object to store.</typeparam>
22
23     /// <remarks>Access to the instance is not synchrnoized.</remarks>
24
25     public class Singleton<T> : Singleton
26
27     {
28
29         static T instance;
30
31
32
33         /// <summary>The singleton instance for the specified type T. Only one instance (at the time) of this object for each type of T.</summary>
34
35         public static T Instance
36
37         {
38
39             get { return instance; }
40
41             set
42
43             {
44
45                 instance = value;
46
47                 AllSingletons[typeof(T)] = value;
48
49             }
50
51         }
52
53     }
54
55
56
57     /// <summary>
58
59     /// Provides a singleton list for a certain type.
60
61     /// </summary>
62
63     /// <typeparam name="T">The type of list to store.</typeparam>
64
65     public class SingletonList<T> : Singleton<IList<T>>
66
67     {
68
69         static SingletonList()
70
71         {
72
73             Singleton<IList<T>>.Instance = new List<T>();
74
75         }
76
77
78
79         /// <summary>The singleton instance for the specified type T. Only one instance (at the time) of this list for each type of T.</summary>
80
81         public new static IList<T> Instance
82
83         {
84
85             get { return Singleton<IList<T>>.Instance; }
86
87         }
88
89     }
90
91
92
93     /// <summary>
94
95     /// Provides a singleton dictionary for a certain key and vlaue type.
96
97     /// </summary>
98
99     /// <typeparam name="TKey">The type of key.</typeparam>
100
101     /// <typeparam name="TValue">The type of value.</typeparam>
102
103     public class SingletonDictionary<TKey, TValue> : Singleton<IDictionary<TKey, TValue>>
104
105     {
106
107         static SingletonDictionary()
108
109         {
110
111             Singleton<Dictionary<TKey, TValue>>.Instance = new Dictionary<TKey, TValue>();
112
113         }
114
115
116
117         /// <summary>The singleton instance for the specified type T. Only one instance (at the time) of this dictionary for each type of T.</summary>
118
119         public new static IDictionary<TKey, TValue> Instance
120
121         {
122
123             get { return Singleton<Dictionary<TKey, TValue>>.Instance; }
124
125         }
126
127     }
128
129
130
131     /// <summary>
132
133     /// Provides access to all "singletons" stored by <see cref="Singleton{T}"/>.
134
135     /// </summary>
136
137     public class Singleton
138
139     {
140
141         static Singleton()
142
143         {
144
145             allSingletons = new Dictionary<Type, object>();
146
147         }
148
149
150
151         static readonly IDictionary<Type, object> allSingletons;
152
153
154
155         /// <summary>Dictionary of type to singleton instances.</summary>
156
157         public static IDictionary<Type, object> AllSingletons
158
159         {
160
161             get { return allSingletons; }
162
163         }
164
165     }
166
167 }

Singleton类里面用一个Dictionary<Type, object>()集合来存储所有的单例对象。基于Singleton类创建一些泛型类Singleton<T>，Singleton<IList<T>>，SingletonList<T>，Singleton<IDictionary<TKey, TValue>>和SingletonDictionary<TKey, TValue>。