说说设计模式~单件模式(Singleton)

返回目录

单件模式（Singleton）要求一个类有且仅有一个实例，并且提供了一个全局的访问点。

从概念上来研究一下它的实现，不考虑线程安全

public sealed class Singlton
{
    static Singlton instance = null;
    private　Singlton() { }
 
    public static Singlton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new Singlton();
            }
            return instance;
        }   
    }   
}

上面的实现方式，对于多线程会有问题，因为Singlton 对象可能不指一次被创建，而罪魁祸首就是if (instance == null)这句话，它并不是线程安全的。

如果希望实现线程安全的单件，我们最先想到的应该就是借助lock机制来实现，代码可能是这样：

public sealed class Singlton
{
    static Singlton instance = null;
 
    static readonly object o = new object();
 
    Singlton()
    { }
 
    public static Singlton Instance
    {
        get
        {
            lock (o)
            {
                if (instance == null)
                {
                    instance= new Singlton();
                }
            21             }
                return instance;
        }   
    }   
}

而我们使用静态对象在静态结构方法里为它进行初始化，这种方式也非常在程序中看到，如：

public sealed class Singlton
{
    static readonly Singlton instance = null;
 
    static Singlton()
    { instance = new Singlton();}
 
    public static Singlton Instance
    {
        get
        {
            return instance;
        }
    }
}

这种方法及其它单件模式有一个问题，就是如果希望去更新单件对象的值，是无法实现的，比如，instance对象希望从数据库中取出一个列表，而列表的信息有可能

发生变化，怎样保证instance里取的是最新的信息呢，这样我们可以在单件中引入时间触发器的概念，代码如下：

    public class CategoryRepository : Car_RentalRepositoryBase, ICategoryRepository
    {
        #region 静态树结构，每1分钟去获一下数据库
        static List<Category> categoryList = null;
        /// <summary>
        /// 数据实体
        /// </summary>
        public static volatile List<Category> Instance = null;
        static CategoryRepository categoryRepository = new CategoryRepository();
        static System.Timers.Timer sysTimer = new System.Timers.Timer(600000);
        static CategoryRepository()
        {
            Reload();//第一次加载
            sysTimer.AutoReset = true;
            sysTimer.Enabled = true;
            sysTimer.Elapsed += new System.Timers.ElapsedEventHandler(sysTimer_Elapsed);
            sysTimer.Start();
        }

        /// <summary>
        /// 被订阅了Elapsed事件的方法,每隔一段时间去重新获取数据列表
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        static void sysTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Reload();
        }

        internal static void Reload()
        {
            categoryList = categoryRepository.GetModel().OrderBy(i => i.SortNumber).ToList();
            Instance = categoryList.Where(i => i.ID != 1).ToList();
        }
}

这种方式解决了实例不能获取最新的问题。

最后，奉献出国外牛人写了的泛型单件类，如果实现的类直接继承它即可。

 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     }

感谢您好阅读，希望本文章对您有帮助。

相关链接：基础才是重中之重~延迟初始化

参考 文献：

http://technet.microsoft.com/zh-cn/magazine/dd997286%28VS.95%29.aspx

http://www.fascinatedwithsoftware.com/blog/post/2011/07/13/A-Generic-Singleton-Class.aspx

返回目录