单件模式（Singleton）要求一个类有且仅有一个实例，并且提供了一个全局的访问点。
从概念上来研究一下它的实现，不考虑线程安全
1 public sealed class Singlton
2 {
3 static Singlton instance = null;
4 private Singlton() { }
6
7 public static Singlton Instance
8 {
9 get
10 {
11 if (instance == null)
12 {
13 instance = new Singlton();
14 }
15 return instance;
16 }
17 }
18 }
上面的实现方式，对于多线程会有问题，因为Singlton 对象可能不指一次被创建，而罪魁祸首就是if (instance == null)这句话，它并不是线程安全的。
如果希望实现线程安全的单件，我们最先想到的应该就是借助lock机制来实现，代码可能是这样：
1 public sealed class Singlton
2 {
3 static Singlton instance = null;
4
5 static readonly object o = new object();
6
7 Singlton()
8 { }
9
10 public static Singlton Instance
11 {
12 get
13 {
14 lock (o)
15 {
16 if (instance == null)
17 {
18 instance= new Singlton();
19 }
20 21 }
return instance;
22 }
23 }
24 }
而我们使用静态对象在静态结构方法里为它进行初始化，这种方式也非常在程序中看到，如：
1 public sealed class Singlton
2 {
3 static readonly Singlton instance = null;
4
5 static Singlton()
6 { instance = new Singlton();}
7
8 public static Singlton Instance
9 {
10 get
11 {
12 return instance;
13 }
14 }
15 }
这种方法及其它单件模式有一个问题，就是如果希望去更新单件对象的值，是无法实现的，比如，instance对象希望从数据库中取出一个列表，而列表的信息有可能
发生变化，怎样保证instance里取的是最新的信息呢，这样我们可以在单件中引入时间触发器的概念，代码如下：
1 public class CategoryRepository : Car_RentalRepositoryBase, ICategoryRepository
2 {
3 #region 静态树结构，每1分钟去获一下数据库
4 static List<Category> categoryList = null;
5 /// <summary>
6 /// 数据实体
7 /// </summary>
8 public static volatile List<Category> Instance = null;
9 static CategoryRepository categoryRepository = new CategoryRepository();
10 static System.Timers.Timer sysTimer = new System.Timers.Timer(600000);
11 static CategoryRepository()
12 {
13 Reload();//第一次加载
14 sysTimer.AutoReset = true;
15 sysTimer.Enabled = true;
16 sysTimer.Elapsed += new System.Timers.ElapsedEventHandler(sysTimer_Elapsed);
17 sysTimer.Start();
18 }
19
20 /// <summary>
21 /// 被订阅了Elapsed事件的方法,每隔一段时间去重新获取数据列表
22 /// </summary>
23 /// <param name="sender"></param>
24 /// <param name="e"></param>
25 static void sysTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
26 {
27 Reload();
28 }
29
30 internal static void Reload()
31 {
32 categoryList = categoryRepository.GetModel().OrderBy(i => i.SortNumber).ToList();
33 Instance = categoryList.Where(i => i.ID != 1).ToList();
34 }
35 }
这种方式解决了实例不能获取最新的问题。
最后，奉献出国外牛人写了的泛型单件类，如果实现的类直接继承它即可。
1 /// <summary>
2 /// 泛型单例基类
3 /// </summary>
4 public abstract class Singleton<TEntity> where TEntity : class
5 {
6 private static readonly Lazy<TEntity> _instance
7 = new Lazy<TEntity>(() =>
8 {
9 var ctors = typeof(TEntity).GetConstructors(
10 BindingFlags.Instance
11 | BindingFlags.NonPublic
12 | BindingFlags.Public);
13 if (ctors.Count() != 1)
14 throw new InvalidOperationException(String.Format("Type {0} must have exactly one constructor.", typeof(TEntity)));
15 var ctor = ctors.SingleOrDefault(c => c.GetParameters().Count() == 0 && c.IsPrivate);
16 if (ctor == null)
17 throw new InvalidOperationException(String.Format("The constructor for {0} must be private and take no parameters.", typeof(TEntity)));
18 return (TEntity)ctor.Invoke(null);
19 });
20
21 public static TEntity Instance
22 {
23 get { return _instance.Value; }
24 }
25 }
