单例模式的C#实现

借鉴各路大神的博客，也就不做链接了

class SingletonPattern
    {
        public sealed class Singleton1
        {
            private static readonly Singleton1 instance = new Singleton1();
            static Singleton1() { }
            private Singleton1() { }
            public static Singleton1 Instance
            {
                get
                {
                    return instance;
                }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello1"); }
        }
        public sealed class Singleton2
        {
            private static readonly Singleton2 instance = null;
            static Singleton2()
            {
                instance = new Singleton2();//静态初始化，不同于Singleton1
            }
            private Singleton2() { }
            public static Singleton2 Instance
            {
                get
                {
                    return instance;
                }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello2"); }
        }
        public sealed class Singleton3
        {
            private static readonly Lazy<Singleton3> lazy = new Lazy<Singleton3>(() => new Singleton3());
            public static Singleton3 Instance
            {
                get
                {
                    return lazy.Value;
                }
            }
            private Singleton3() { }
            //测试方法
            public void Hello() { Console.WriteLine("Hello3"); }
        }
        /// <summary>
        /// 最简单的单例，但线程不安全，对于单线程已然满足
        /// </summary>
        public sealed class Singleton4
        {
            private static Singleton4 instance = null;
            private Singleton4() { }
            public static Singleton4 Instance
            {
                get
                {
                    if (instance == null)
                    {
                        instance = new Singleton4();
                    }
                    return instance;
                }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello4"); }
        }
        /// <summary>
        /// 一重加锁，增加开销，保证线程安全
        /// </summary>
        public sealed class Singleton5
        {
            private static Singleton5 instance = null;
            private static readonly object padlock = new object();
            private Singleton5() { }
            public static Singleton5 Instance
            {
                get
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new Singleton5();
                        }
                        return instance;
                    }
                }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello5"); }
        }
        /// <summary>
        /// 两重加锁，减少一重加锁的性能消耗，线程安全
        /// </summary>
        public sealed class Singleton6
        {
            private static Singleton6 instance = null;
            private static readonly object padlock = new object();
            private Singleton6() { }
            public static Singleton6 Instance
            {
                get
                {
                    if (instance == null)
                    {
                        lock (padlock)
                        {
                            if (instance == null)
                            {
                                instance = new Singleton6();
                            }
                        }
                    }
                    return instance;
                }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello6"); }
        }
        public sealed class Singleton7
        {
            private Singleton7() { }
            public static Singleton7 Instance
            {
                get
                {
                    return Nested.instance;
                }
            }
            private class Nested//通过内嵌的私有类做延时初始化
            {
                static Nested() { }
                private Nested() { }
                internal static readonly Singleton7 instance = new Singleton7();
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello7"); }
        }
        public sealed class Singleton8
        {
            private Singleton8() { }
            public static Singleton8 Instance
            {
                get
                {
                    return Nested.instance;
                }
            }
            private class Nested
            {
                internal static readonly Singleton8 instance = null;
                static Nested()
                {
                    instance = new Singleton8();//都是延时初始化，但不同于Singleton7的是静态初始化，类似Singleton1和Singleton2的区别
                }
                private Nested() { }
            }
            //测试方法
            public void Hello() { Console.WriteLine("Hello8"); }
        }
        //对于使用Unity的朋友Singleton4够了
    }