function Node(key,value){//键值对对象
    this.key=key;
    this.value=value;
}

function Map(){//Map类
    this.nodes=new Array();
}

Map.prototype.put=function(key,value){//往容器中加入一个键值对
        for(var i=0;i<this.nodes.length;i++)
           if(this.nodes[i].key==key){//如果键值已存在，则put方法为更新已有数据
               this.nodes[i].value=value;
               return;
           }
        var node=new Node(key,value);
        this.nodes.push(node);
        return;
}//put

  
Map.prototype.get=function(key){//获取指定键的值
        for(var i=0;i<this.nodes.length;i++)
           if(this.nodes[i].key==key)
              return this.nodes[i].value;
        return null;
}//get
    
Map.prototype.size=function(){//获取容器中对象的个数
     return this.nodes.length;
}//size

        
Map.prototype.clear=function(){//清空容器
     while(this.nodes.length>0)
        this.nodes.pop();     
}//clear
 
Map.prototype.remove=function(key){//删除指定值
     for(var i=0;i<this.nodes.length;i++)
        if(this.nodes[i].key==key){
           if(i>0)
              var nodes1=this.nodes.concat(this.nodes.slice(0,i-1),this.nodes.slice(i+1));
           else//删除的是第一个元素
             var nodes1=nodes.slice(1);
           this.nodes=nodes1;

        }
}//remove

   
Map.prototype.isEmpty=function(){//是否为空
     if(this.nodes.length==0)
       return true;
     else
       return false;
}//isEmpty
   
Map.prototype.toString=function(){
     var str="[";
     for(var i=0;i<this.nodes.length;i++){
        if(i<this.nodes.length-1)
           str=str+this.nodes[i].key+",";
       else
           str=str+this.nodes[i].key;    
    }
    str=str+"]";
    return str;
}

/// <summary>
/// DbConnectionPool 的摘要说明
/// </summary>

namespace dbopr
{
    public class DbConnectionPool
    {
        //定义存放数据库链接的队列
        private static Queue connections=new Queue();

        //数据库参数
        private static string ConnString = "";                                    //链接字符串

        //链接池参数
        private static int InitSize = 20;                                         //初始化链接池大小
        private static int MaxSize = 100;                                         //最大链接数
        private static int QueueSize = 50;                                        //队列中最大维护的链接数
        private static int ConnNum = 0;                                           //系统维护的链接总数

        //定义数据库类型，1表示为SqlServer数据库，2表示其它的OLE DB；默认为SqlServer
        private static int  DbType = 1;
        public static int DbType
        {
            set
            {
                DbType = value;
            }
        }

        private DbConnectionPool()
        {
            try{
                ConnString = Configuration.connectionStrings["DbSource"].connectionString;
                InitSize = int.Parse(Configuration.connectionStrings["InitSize"].connectionString);
                MaxSize = int.Parse(Configuration.connectionStrings["MaxSize"].connectionString);
                QueueSize = int.Parse(Configuration.connectionStrings["QueueSize"].connectionString);
                DbType = int.Parse(Configuration.connectionStrings["DbType"].connectionString);
                initPool();
            }
            catch(Exception e) {
            }
        }
       
        //初始化链接池
        private static void initPool(){
            int i;
            for (i = 1; i <= InitSize; i++) {
                if (DbType == 1)
                    connections.Enqueue(newSqlConn());
                else
                    connections.Enqueue(newOleConn());
            }
        }

        //获取一个Sql Server链接对象
        private static SqlConnection newSqlConn()
        {
            ConnNum++;
            return new SqlConnection(ConnString);
        }
       
        //获取一个OLE DB链接对像
        private static OleDbConnection newOleConn()
        {
            ConnNum++;
            return new OleDbConnection(ConnString);
        }

        //获取一个数据库链接
        public static IDbConnection getConn() {
            if (connections.Count == 0)                                  //如果队列中链接用完，则新建一个链接放入队列
            {
                if (ConnNum > MaxSize)                                   //如果当前活动链接达到最大，则等待链接
                    return null;
                else
                {
                    if (DbType == 1)
                        connections.Enqueue(newSqlConn());
                    else
                        connections.Enqueue(newOleConn());
                    return connections.Dequeue();
                }
            }
            else
                return connections.Dequeue();
        }

        //释放一个活运链接
        public static void reConn(IDbConnection conn) {
            if (connections.Count > QueueSize)                           //如果队列中元素个数已达到最大，则关闭链接
                conn.Close();
            else
                connections.Enqueue(conn);
        }

        //销毁链接池
        public static void ClearPool() {
            while(connections.Count>0)
                 (IDbConnection)connections.Dequeue().Close();
        }
    }
}

2.链接生成类
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Configuration;
using System.Web;

/// <summary>
/// DbConn 的摘要说明
/// </summary>

namespace dbopr
{
    public class DbConnection
    {
        private static IDbConnection conn;
       
        public DbConnection()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

        public static SqlConnection getSqlConn()
        {
            //获取链接池中的Sql Server的链接
            conn = DbConnectionPool.getConn();
            return (SqlConnection)conn;
        }

        public static OleDbConnection getOleConn() {
            //获取其它OLE DB的链接
            conn = DbConnectionPool.getConn();
            return (OleDbConnection)conn;
        }

        public static void Close() {
            //放回用过的链接
            DbConnectionPool.reConn(conn);
        }
    }
}