connectionpool.cs

一个实用的数据库连接池源码

using System;
using System.Collections;
using System.Data.SqlClient;
using System.Threading;

namespace ConnectionPool
{
	/// <summary>
	/// Summary description for DatabasePool.
	/// </summary>
	public class ConnectionPool
	{
		private static ConnectionPool _instance = null;
		private ArrayList _list = new ArrayList();
		private int maxConnection = 100;  //系统可以使用的最大连接数，超过这个就拒绝客户连接
		private int minConnection = 20;  //连接池中连接数目。
		private int usedConnection = 0;  //已经被使用的连接数目。
        private static object syncLocker = new object();  //sync locker object.
        private string _server = null; //server string
        private string _db = null; //db string 
        private string _connectString = null;  //connection string.

		/**
		 *  连接池构造函数
		 * 
		 */
		private ConnectionPool()
		{
		}

        /**
         *  set connection string value.
         */
        public string ConnectString
        {
            set { _connectString = value; }
        }

        /**
         * return max connection number limited.
         */
        public int MaxConnAllow
        {
            get { return maxConnection; }
        }

        /**
         *  return connection pool size
         */
        public int PoolSize
        {
            get { return minConnection; }
        }

        /**
         *  return current using connection.
         */
        public int UsedConnection
        {
            get { return usedConnection; }
        }
		/*
		 * get a pool instance
		 * 
		 */
		public static ConnectionPool Instance() 
		{
			if(_instance == null) {
                _instance = new ConnectionPool();
			}

			return _instance;
		}

		/*
		 * connection pool created 
         * initSize is initialization number 
		 */
		public void CreatePool(string server, string db) 
		{
            lock (syncLocker)
            {
                _server = server;
                _db = db;
                try
                {
                    for (int i = 0; i < minConnection; i++)
                    {
                        DBConn conn = new DBConn();
                        conn.ConnectString = this._connectString;
                        conn.Open(_server, _db);
                        _list.Add(conn);
                        Thread.Sleep(100);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception("CreatePool Found Exception : " + ex.Message);
                }
            }
		}

		/*
		 * destroy connection pool.
		 */
		public void DestroyPool() 
		{
            lock (syncLocker)
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    DBConn conn = (DBConn)_list[i];
                    conn.Destroy();
                    _list.Remove(conn);
                }
            }
		}

		/*
		 * get a connection from pool or
		 * create a connection by user.
		 */
        public DBConn Acquire()
		{
            lock (syncLocker)
            {
                //Console.WriteLine("Acquire Called");
                foreach (DBConn conn in _list)
                {
                    if (!conn.IsUsed)
                    {
                        conn.IsUsed = true;
                        this.usedConnection++;
                        return conn;
                    }
                }
                if (this.usedConnection < this.maxConnection)
                {
                    try
                    {
                        //Console.WriteLine("Acquire User Created Called");
                        DBConn conn = new DBConn();
                        conn.Open(_server, _db);
                        conn.IsOutOfPool = true;
                        this.usedConnection++;
                        return conn;
                    }
                    catch (Exception ex)
                    {
                        throw new Exception("Acquire Found Exception : " + ex.Message);
                    }
                }

                return null;
            }
		}

		/*
		 * release a connection and make it 
		 * free again
		 */
        public void Release(DBConn conn) 
		{
            conn.IsUsed = false;
            conn.Close();
            this.usedConnection--;
		}

	}
}