在DotNet中使用Singleton模式

using System;
using System.Collections;
namespace Singleton.SingletonFolder
{
    /**//// <summary>
    /// SubSingletonB 的摘要说明。
    /// </summary>
    public class SubSingletonB :SingletonB
    {

        private static bool instanceFlag = false;

        public SubSingletonB() 
            
        {
            try 
            {
                if(instanceFlag) 
                {
                    throw new SingletonException("Only can create a instance !");
                } 
                else 
                {
                    instanceFlag = true;
                    SingletonB.Register("Sub1", this);
                }
            } 
            catch (SingletonException ex) 
            {
                throw ex;
            }
        }

        public void finalize() 
        {
            instanceFlag = false;
        }
    }
    
    
    /**//// <summary>
    /// SingletonException 为异常类
    /// </summary>
    public class SingletonException :Exception 
    {
        public SingletonException():base()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        public SingletonException(string msg) :base(msg) 
        {
        }
    }
    
    
    /**//// <summary>
    /// 特点:singleton能够被状态化(论坛中的帖子计数器);
    ///      单线程操作(建立目录 数据库连接);
    ///      singleton能够被无状态化(工具性质的功能);
    /// 缺点:如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术
    /// </summary>
    public class SingletonB
    {
        private static Hashtable registry = new Hashtable();
        
        public SingletonB()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

        /**//// <summary>
        /// 注册
        /// </summary>
        /// <param name="name">名称</param>
        /// <param name="aInstance">进程</param>
        public static void Register(string name,SingletonB aInstance) 
        {
            registry.Add(name,aInstance);

        }
        /**//// <summary>
        /// 取得进程
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static SingletonB GetInstance(string name) 
        {
            return LookUp(name);
        }
        
        private static SingletonB LookUp (string name) 
        {
            return (SingletonB)registry[name];
        }
    }
    
    /**//// <summary>
    /// SingletonA 的摘要说明。
    /// </summary>
    public class SingletonA
    {
        
        public static bool instanceFlag = false; 
        
        private int i = 0;
    
        // Set constructor private and do nothing
        // Can not new a instance outside class
        private SingletonA() 
        {
        }
        public int getNum() 
        {
            return i;
        }
    
        public void setNum() 
        {
            i++;
        }

    
        public static SingletonA getInstance() 
        {
            if(! instanceFlag) 
            {
                instanceFlag = true;
                return new SingletonA();
            }
            return null;
        }

        public void finalize() 
        {
            instanceFlag = false;
        }
    }
    
    class SingletonTest
    {
        /**//// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            //runB();
            runA();
        }

        /**//// <summary>
        /// 测试SingletonB
        /// </summary>
        static void runB()
        {
            SingletonB instance1 = SingletonB.GetInstance("Sub1");
            
            
            if(instance1 == null) 
            {
                System.Console.WriteLine ("There is no such instance in registry !");
            } 
            else 
            {
                System.Console.WriteLine (instance1.ToString() );
            }
            
            try 
            {
                SingletonB instance2 = new SubSingletonB();
                System.Console.WriteLine ("We had created a new instance named \"Sub1\" now");
            } 
            catch (SingletonException e) 
            {
                System.Console.WriteLine (e.Message);
            }
            
            // To get instance again
            instance1 = SingletonB.GetInstance("Sub1");
        
            
            if(instance1 == null) 
            {
                System.Console.WriteLine ("There is no such instance in registry !");
            } 
            else 
            {
                System.Console.WriteLine (instance1.ToString());
            }

            // Finally we create a new instance again
            
            try 
            {
                SingletonB instance3 = new SubSingletonB();
                System.Console.WriteLine ("We had created a new instance named \"Sub1\" now");
            } 
            catch (SingletonException e) 
            {
                System.Console.WriteLine (e.Message);
            }
            System.Console.ReadLine();     
        }
        


        static void runA() 
        {
             SingletonA instance2 = SingletonA.getInstance();
            if(instance2 != null) {
                instance2.setNum();
                System.Console.WriteLine ("i is:" + instance2.getNum());
            }
            SingletonA instance3 = SingletonA.getInstance();
            if(instance3 == null) {
                System.Console.WriteLine("Can not get instance twice !");   
            }
            Console.ReadLine();
        }
    }
}

Singleton模式主要作用是保证在应用程序中，一个类Class只有一个实例存在。
很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数。