ado.net连接池

ado.NET中提供了连接池的功能，多数开发人员很少设置它，因为它是默认的。

界面设置如下图：

关闭连接池也很简单，在连接字符串如下：

1. Data Source=(local);Initial Catalog=AdventureWorks;Integrated Security=SSPI;Pooling=False; 

但连接池的本质是什么样的呢？

用Reflector，打开System.Data.SqlClient.SqlConnection的ConnectionString属性的设置值的方法，如下：

1. private void ConnectionString_Set(string value) 
2.  
3. { 
4.  
5.     DbConnectionOptions userConnectionOptions = null; 
6.  
7.     DbConnectionPoolGroup group = this.ConnectionFactory.GetConnectionPoolGroup(value, null, ref userConnectionOptions); 
8.  
9.     DbConnectionInternal innerConnection = this.InnerConnection; 
10.  
11.     bool allowSetConnectionString = innerConnection.AllowSetConnectionString; 
12.  
13.     if (allowSetConnectionString) 
14.  
15.     { 
16.  
17.         allowSetConnectionString= this.SetInnerConnectionFrom(DbConnectionClosedBusy.SingletonInstance, innerConnection); 
18.  
19.         if (allowSetConnectionString) 
20.  
21.         { 
22.  
23.             this._userConnectionOptions = userConnectionOptions; 
24.  
25.             this._poolGroup = group; 
26.  
27.             this._innerConnection = DbConnectionClosedNeverOpened.SingletonInstance; 
28.  
29.         } 
30.  
31.     } 
32.  
33.     if (!allowSetConnectionString) 
34.  
35.     { 
36.  
37.         throw ADP.OpenConnectionPropertySet("ConnectionString", innerConnection.State); 
38.  
39.     } 
40.  
41.     if (Bid.TraceOn) 
42.  
43.     { 
44.  
45.         string str = (userConnectionOptions != null) ? userConnectionOptions.UsersConnectionStringForTrace() : ""; 
46.  
47.         Bid.Trace("<prov.DbConnectionHelper.ConnectionString_Set|API> %d#, '%ls'\n", this.ObjectID, str); 
48.  
49.     } 
50.  
51. } 
52.  
53. 再连接 到红色的GetConnectionPoolGroup方法，如下代码 
54.  
55.  internal DbConnectionPoolGroup GetConnectionPoolGroup(string connectionString, DbConnectionPoolGroupOptions poolOptions, ref DbConnectionOptions userConnectionOptions) 
56.  
57. { 
58.  
59.     DbConnectionPoolGroup group; 
60.  
61.     if (ADP.IsEmpty(connectionString)) 
62.  
63.     { 
64.  
65.         return null; 
66.  
67.     } 
68.  
69.     if (!this._connectionPoolGroups.TryGetValue(connectionString, out group) || (group.IsDisabled && (group.PoolGroupOptions != null))) 
70.  
71.     { 
72.  
73.         DbConnectionOptions options = this.CreateConnectionOptions(connectionString, userConnectionOptions); 
74.  
75.         if (options == null) 
76.  
77.         { 
78.  
79.             throw ADP.InternalConnectionError(ADP.ConnectionError.ConnectionOptionsMissing); 
80.  
81.         } 
82.  
83.         string str = connectionString; 
84.  
85.         if (userConnectionOptions == null) 
86.  
87.         { 
88.  
89.             userConnectionOptions = options; 
90.  
91.             str = options.Expand(); 
92.  
93.             if (str != connectionString) 
94.  
95.             { 
96.  
97.                 return this.GetConnectionPoolGroup(str, null, ref userConnectionOptions); 
98.  
99.             } 
100.  
101.         } 
102.  
103.         if ((poolOptions == null) && ADP.IsWindowsNT) 
104.  
105.         { 
106.  
107.             if (group != null) 
108.  
109.             { 
110.  
111.                 poolOptions = group.PoolGroupOptions; 
112.  
113.             } 
114.  
115.             else 
116.  
117.             { 
118.  
119.                 poolOptions = this.CreateConnectionPoolGroupOptions(options); 
120.  
121.             } 
122.  
123.         } 
124.  
125.         DbConnectionPoolGroup group2 = new DbConnectionPoolGroup(options, poolOptions) { 
126.  
127.             ProviderInfo = this.CreateConnectionPoolGroupProviderInfo(options) 
128.  
129.         }; 
130.  
131.         lock (this) 
132.  
133.         { 
134.  
135.             Dictionary<string, DbConnectionPoolGroup> dictionary = this._connectionPoolGroups; 
136.  
137.             if (!dictionary.TryGetValue(str, out group)) 
138.  
139.             { 
140.  
141.                 Dictionary<string, DbConnectionPoolGroup> dictionary2 = new Dictionary<string, DbConnectionPoolGroup>(1 + dictionary.Count); 
142.  
143.                 foreach (KeyValuePair<string, DbConnectionPoolGroup> pair in dictionary) 
144.  
145.                 { 
146.  
147.                     dictionary2.Add(pair.Key, pair.Value); 
148.  
149.                 } 
150.  
151.                 dictionary2.Add(str, group2); 
152.  
153.                 this.PerformanceCounters.NumberOfActiveConnectionPoolGroups.Increment(); 
154.  
155.                 group = group2; 
156.  
157.                 this._connectionPoolGroups = dictionary2; 
158.  
159.             } 
160.  
161.             return group; 
162.  
163.         } 
164.  
165.     } 
166.  
167.     if (userConnectionOptions == null) 
168.  
169.     { 
170.  
171.         userConnectionOptions = group.ConnectionOptions; 
172.  
173.     } 
174.  
175.     return group; 
176.  
177. } 
178.  
179. TryGetValue是判断是否存在连接字符串为connectionString的连接，存在返回到group，不存在就调用CreateConnectionOptions创建一个DbConnectionOptions，最后用 
180.  
181. lock (this) 
182.  
183.         { 
184.  
185.             Dictionary<string, DbConnectionPoolGroup> dictionary = this._connectionPoolGroups; 
186.  
187.             if (!dictionary.TryGetValue(str, out group)) 
188.  
189.             { 
190.  
191.                 Dictionary<string, DbConnectionPoolGroup> dictionary2 = new Dictionary<string, DbConnectionPoolGroup>(1 + dictionary.Count); 
192.  
193.                 foreach (KeyValuePair<string, DbConnectionPoolGroup> pair in dictionary) 
194.  
195.                 { 
196.  
197.                     dictionary2.Add(pair.Key, pair.Value); 
198.  
199.                 } 
200.  
201.                 dictionary2.Add(str, group2); 
202.  
203.                 this.PerformanceCounters.NumberOfActiveConnectionPoolGroups.Increment(); 
204.  
205.                 group = group2; 
206.  
207.                 this._connectionPoolGroups = dictionary2; 
208.  
209.             } 
210.  
211.             return group; 
212.  
213.         } 

这段代码放到连接池中，在这里，可能显示的看到，ado.NET的连接池实质上是一个Dictionary<string, DbConnectionPoolGroup>泛型集合。

所谓的连接池，就是一个与连接对象Connection相关的集合，这不只是简单的集合，而是有一定的机制在内部。我们做开发时，可能建立Connection连接对象，关闭连接对象，有时候还调用Dispose来释放连接。下次再用时，便重新实例化一个连接。但在池中的连接不随连接对象的Close或Dispose而释放。如果下次重新建立连接，连接字符串与前一次完全一模一样，则连接池就会把上次可用的连接对象赋给连接去用。如果两个连接字符串有一点不一样，即使在某一个地方多一个空格，连接池也不会以为是相同的连接，这点微软可能在内部只直接去比较两个字符串了，而不是比较连接数据库字符串的键值互相匹配。

连接池的好处就是保留连接对象，防止下次重头再来实例化一个连接对象。


（说明：可能找到结果后觉得非常简单，但怎么找到结果的，却是费了很大劲，几乎是5个小时，所以相把找到结果的过程简单说一下：

一开始用Reflector发现SqlConnection中有一个PoolGroup的属性，于是就想在运行时候比较两个SqlConnection对象的这个属性，但由于这个属性是的访问修饰符是internal的，不能直接访问，只有用反射，代码（是经过优化的）如下：

1. string constr1 = "Data Source=(local);Initial Catalog=AdventureWorks;Integrated Security=SSPI;"; 
2.  
3.            string constr2 = "Data Source=(local);Initial Catalog=Pubs;Integrated Security=SSPI;"; 
4.  
5.            string AssMark = "System.Data,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; 
6.  
7.            Assembly ass = Assembly.Load(AssMark); 
8.  
9.  
10.  
11.            Type SqlConType = null; 
12.  
13.            foreach (Type conType in ass.GetExportedTypes()) 
14.  
15.            { 
16.  
17.                Console.WriteLine(conType .ToString ()); 
18.  
19.                if ("System.Data.SqlClient.SqlConnection" == conType.ToString()) 
20.  
21.                { 
22.  
23.                    SqlConType = conType; 
24.  
25.                } 
26.  
27.            } 
28.  
29.            if (SqlConType != null) 
30.  
31.            { 
32.  
33.                Type types1 = new Type[0]; 
34.  
35.                ConstructorInfo constructorInfoObj1 = SqlConType.GetConstructor( 
36.  
37.                     BindingFlags.Instance | BindingFlags.Public, null, 
38.  
39.                     CallingConventions.HasThis, types1, null); 
40.  
41.                SqlConnection con1 = (SqlConnection)constructorInfoObj1.Invoke(null); 
42.  
43.                con1.ConnectionString = constr1;            
44.  
45.                SqlConnection con2 = (SqlConnection)constructorInfoObj1.Invoke(null); 
46.  
47.                con2.ConnectionString = constr2; 
48.  
49.                PropertyInfo PI = SqlConType.GetProperty("PoolGroup", BindingFlags.Instance | BindingFlags.NonPublic); 
50.  
51.                object poolGroup1 = PI.GetValue(con1, null); 
52.  
53.                object poolGroup2 = PI.GetValue(con2, null);  
54.  
55.            } 

然后在倒数第一行设置断点，为比较poolGroup1和poolGroup2的不同，结果发现，当连接字符串一样时，这两个对象的_objectID相同，字符串有一点不同就会不同，这点说明连接池中是用字符串本身比较的，而不是字符串中键值对进行比较。同还发现当con1和con2的ConnectionString不赋值时这两个对象都是null，由此说明关键是ConnectionString赋值上，所以才开始用Reflector查看这个属性的赋值方法，才有上面的代码。）