泛型单一模式

泛型单一模式类：（fully lazy instantiation） 

public   sealed   class  Singleton < T >
         where  T :  class
    {
        
         public   static  T Instance
        {
             get
            {
                 return  Nested.instance;
            }
        }

         private   class  Nested
        {
             //  Explicit static constructor to tell C# compiler
             //  not to mark type as beforefieldinit
             static  Nested()
            {
            }

             internal   static   readonly  T instance  =   typeof (T).InvokeMember( typeof (T).Name, BindingFlags.CreateInstance  |  BindingFlags.Instance  |  BindingFlags.NonPublic,  null ,  null ,  null )  as  T;
        }
    }

实现要点
1. 静态构造函数
静态构造函数用于初始化任何静态数据，所以它的执行顺序应该在静态成员初始化之后。

class  Test
    {
         static   int  value =   1 ;  // 第一步

         static   string  staticString;

         static  Test()
        { // 第三步
            value  =   2 ;
            value2 =   3 ;
        }

         public   static   int  value2 =   1 ;  // 第二步

    }

当程序第一次执行如下语句时
Test test =   new  Test();
执行顺序就是上面标出的步骤。
也就是说 
test.value  =   2
test.value2  =   3

2. 嵌套类的静态构造函数的作用
嵌套类的静态构造函数不会随着外部类的触发而初始化。有了嵌套类的静态构造函数，它会告诉C#编译器只有当需要使用内嵌类的时候，嵌套类的静态数据才开始初始化。所以上面介绍的单一模式是属于完全延迟初始化。
3.利用反射时使用"BidingFlags.NonPublic”,确保调用的的具体单一实例类中的private constructor.事实上，具体单一实例类中不应该有public的构造函数。为了就是确保不被误实例化。
4.使用sealed 关键字，防止被继承。

具体单一实例类: 

Code
/// <summary>
    /// SingleInstanceClass is a Singleton.
    /// </summary>
    public class SingleInstanceClass
    {
        #region Constructors

        /// <summary>
        /// Private constructor to prevent casual instantiation of this class.
        /// </summary>
        private SingleInstanceClass() 
        {
            // Show that the constructor is called.
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("SingleInstanceClass created.");
            Console.ResetColor();

            // Increment instance counter.
            _count++;
        }

        #endregion Constructors


        #region Properties

        /// <summary>
        /// Gets the single instance of SingleInstanceClass.
        /// </summary>
        public static SingleInstanceClass Instance 
        { 
            get { return Singleton<SingleInstanceClass>.Instance; } 
        }

        /// <summary>
        /// Gets the number of SingleInstanceClass instances that have been created.
        /// </summary>
        public static int Count { get { return _count; } }

        #endregion Properties



        #region Methods

        /// <summary>
        /// Simulates a static call.
        /// </summary>
        public static void DoStatic() { Console.WriteLine("DoStatic() called."); }

        /// <summary>
        /// Simulates an instance call.
        /// </summary>
        public void DoInstance() { Console.WriteLine("DoInstance() called."); }

        #endregion Methods


        #region Members

        /// <summary>
        /// Instance counter.
        /// </summary>
        private static int _count = 0;

        #endregion Members
    }

 Main：

Code
/**//// <summary>
    /// Singleton demo program.
    /// </summary>
    class Program
    {
        /**//// <summary>
        /// Entry point.
        /// </summary>
        static void Main()
        {            

            // Show that initially the count is 0; calls a static property which doesn't create the Singleton.
            Console.WriteLine("---");
            Console.WriteLine("Initial instance count: {0}", SingleInstanceClass.Count);

            // Similar to above; show explicitly that calling a static methods doesn't create the Singleton.
            Console.WriteLine("---");
            Console.WriteLine("Calling DoStatic()");
            SingleInstanceClass.DoStatic();
            Console.WriteLine("Instance count after DoStatic(): {0}", SingleInstanceClass.Count);

            // Show that getting the instance creates the Singleton.
            Console.WriteLine("---");
            Console.WriteLine("Calling DoInstance()");
            SingleInstanceClass.Instance.DoInstance();
            Console.WriteLine("Instance count after first DoInstance(): {0}", SingleInstanceClass.Count);

            // Show that getting the instance again doesn't re-instantiate the class.
            Console.WriteLine("---");
            Console.WriteLine("Calling DoInstance()");
            SingleInstanceClass.Instance.DoInstance();
            Console.WriteLine("Instance count after second DoInstance(): {0}", SingleInstanceClass.Count);
            Console.ReadKey();



        }
    }

为什么不用double-check locking来实现，请参照

http://www.yoda.arachsys.com/csharp/singleton.html 

泛型单一模式参考地址:

http://www.codeproject.com/KB/architecture/GenericSingletonPattern.aspx