单例模式 Lazy 按需延迟加载

　　在我们刚学设计模式的时候，单例模式可能是设计模式中最简单最容理解的吧。今天我们就来探究他不一样的风格,不一样的单例模式

　　首先，我们来看一下通俗的单例模式的设计

public class Person
    {　　　　　//这里必须要写私有构造函数
        private Person() { }

        public string Name { get; set; }
        public string Age { get; set; }

        private static object obj = new object();
        private static Person _person;
　　　　//单例属性
        public static Person Instance
        {
            get {
                if (_person == null)
                {
                    lock (obj)
                    {
                        if (_person == null)
                        {
                            _person = new Person();
                        }
                    }
                }
                return _person;
            }
        }
    }

　   这种单例模式虽然正确的，但是要注意几个问题，

　　第一 构造函数必须是私有构造函数

　　第二 必须加上锁，才能保证唯一实例

　  如果说到这里就完了，那我没有必要写这篇文章，因为你一百度就会有一大把。我会有什么不一样的风格，那我们还要学习一个知识点，那是在一篇文章中无意看到的（Lazy），他是一个按需加载的泛型类。

下面验证他是否是按需加载的类

1  Lazy<Person1> la = new Lazy<Person1>();
2             Console.WriteLine(la.IsValueCreated); //实体是否被创建
3             Console.WriteLine(la.Value.Name);
4             Console.WriteLine(la.IsValueCreated);
5 class Person1
6     {
7         public string Name { get { return "啄木鸟"; } }
8     }

得出结果

从上面的结果看来，他确实是按需加载， 那按需加载他有什么好处，好处在于他能在 需要他的时候实例，防止系统刚启动时慢，等原因，

要解决单例模式，必须要在多线程内唯一，Lazy 解决了线程 内的唯一（他的详细内容 请百度，因为他在这篇文章中不是重点）

有了这些知识点有没有想把他封装成一个基类 ，只要继承他就实现了单例模式，这就是我说的不一样的风格

 public abstract  class Singleton<TEntity> where TEntity:class
    {
        private static readonly Lazy<TEntity> m_Instance = new Lazy<TEntity>(() => {
            var ctors = typeof(TEntity).GetConstructors(
                BindingFlags.Instance
                |BindingFlags.NonPublic
                |BindingFlags.Public);
            if (ctors.Count() != 1)
            {
                throw new InvalidOperationException(String.Format("类 {0} 必须包含一个构造函数", typeof(TEntity)));
            }
            var ctor = ctors.SingleOrDefault(c=>c.GetParameters().Count()==0&&c.IsPrivate);
            if (ctor == null)
            {
                throw new InvalidOperationException(String.Format("构造函数{0}必须是无参数并且私有的", typeof(TEntity)));
            }

            return (TEntity)ctor.Invoke(null);

        });

        public static TEntity Instance
        {
            get { return m_Instance.Value; }
        }
    }

　　继承单例内代码

 public class Person : Singleton<Person>
    {
        private Person() { }

        public string Name { get; set; }
        public string Age { get; set; }

    }

　　调用方式

 Console.WriteLine(Person.Instance.Name);

　　结果：

这样是不是简单多了，如果有什么不懂的地方 QQ:209229923