CSHARP-3664: Clarify whether maxPoolSize allows 0 option or no. (#532)

DmitryLukyanov · web-flow · commit 9c34b84089bf · 2021-06-22T17:20:33.000+03:00
CSHARP-3664: Clarify whether maxPoolSize allows 0 option or no.
diff --git a/src/MongoDB.Driver.Core/Core/Configuration/ClusterBuilderExtensions.cs b/src/MongoDB.Driver.Core/Core/Configuration/ClusterBuilderExtensions.cs
@@ -23,6 +23,7 @@
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Events.Diagnostics;
 using MongoDB.Driver.Core.Misc;
+using MongoDB.Shared;
 
 namespace MongoDB.Driver.Core.Configuration
 {
@@ -182,7 +183,8 @@ public static ClusterBuilder ConfigureWithConnectionString(
             // Connection Pool
             if (connectionString.MaxPoolSize != null)
             {
-                builder = builder.ConfigureConnectionPool(s => s.With(maxConnections: connectionString.MaxPoolSize.Value));
+                var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(connectionString.MaxPoolSize.Value);
+                builder = builder.ConfigureConnectionPool(s => s.With(maxConnections: effectiveMaxConnections));
             }
             if (connectionString.MinPoolSize != null)
             {
@@ -195,9 +197,9 @@ public static ClusterBuilder ConfigureWithConnectionString(
             }
             else if (connectionString.WaitQueueMultiple != null)
             {
-                var maxConnections = connectionString.MaxPoolSize ?? new ConnectionPoolSettings().MaxConnections;
-                var waitQueueSize = (int)Math.Round(maxConnections * connectionString.WaitQueueMultiple.Value);
-                builder = builder.ConfigureConnectionPool(s => s.With(waitQueueSize: waitQueueSize));
+                var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(connectionString.MaxPoolSize) ?? new ConnectionPoolSettings().MaxConnections;
+                var computedWaitQueueSize = ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, connectionString.WaitQueueMultiple.Value);
+                builder = builder.ConfigureConnectionPool(s => s.With(waitQueueSize: computedWaitQueueSize));
             }
 #pragma warning restore 618
             if (connectionString.WaitQueueTimeout != null)
diff --git a/src/MongoDB.Driver.Core/Core/Configuration/ConnectionPoolSettings.cs b/src/MongoDB.Driver.Core/Core/Configuration/ConnectionPoolSettings.cs
@@ -15,6 +15,7 @@
 
 using System;
 using MongoDB.Driver.Core.Misc;
+using MongoDB.Shared;
 
 namespace MongoDB.Driver.Core.Configuration
 {
@@ -49,7 +50,9 @@ public ConnectionPoolSettings(
             _maintenanceInterval = Ensure.IsInfiniteOrGreaterThanOrEqualToZero(maintenanceInterval.WithDefault(TimeSpan.FromMinutes(1)), "maintenanceInterval");
             _maxConnections = Ensure.IsGreaterThanZero(maxConnections.WithDefault(100), "maxConnections");
             _minConnections = Ensure.IsGreaterThanOrEqualToZero(minConnections.WithDefault(0), "minConnections");
-            _waitQueueSize = Ensure.IsGreaterThanOrEqualToZero(waitQueueSize.WithDefault(_maxConnections * 5), "waitQueueSize");
+#pragma warning disable CS0618 // Type or member is obsolete
+            _waitQueueSize = Ensure.IsGreaterThanOrEqualToZero(waitQueueSize.WithDefault(ConnectionStringConversions.GetComputedWaitQueueSize(_maxConnections, 5)), "waitQueueSize");
+#pragma warning restore CS0618 // Type or member is obsolete
             _waitQueueTimeout = Ensure.IsInfiniteOrGreaterThanOrEqualToZero(waitQueueTimeout.WithDefault(TimeSpan.FromMinutes(2)), "waitQueueTimeout");
         }
 
diff --git a/src/MongoDB.Driver.Core/MongoDB.Driver.Core.csproj b/src/MongoDB.Driver.Core/MongoDB.Driver.Core.csproj
@@ -154,6 +154,7 @@
 
   <ItemGroup>
     <Compile Include="..\MongoDB.Shared\ApplicationNameHelper.cs" Link="Core\Configuration\ApplicationNameHelper.cs" />
+    <Compile Include="..\MongoDB.Shared\ConnectionStringConversions.cs" Link="Core\Misc\ConnectionStringConversions.cs" />
     <Compile Include="..\MongoDB.Shared\Hasher.cs" Link="Core\Misc\Hasher.cs" />
     <Compile Include="..\MongoDB.Shared\MaxTimeHelper.cs" Link="Core\Operations\MaxTimeHelper.cs" />
     <Compile Include="..\MongoDB.Shared\OperatingSystemHelper.cs" Link="Core\Misc\OperatingSystemHelper.cs" />
diff --git a/src/MongoDB.Driver.Legacy/MongoDB.Driver.Legacy.csproj b/src/MongoDB.Driver.Legacy/MongoDB.Driver.Legacy.csproj
@@ -6,7 +6,7 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard1.5;netstandard2.0;netstandard2.1;net452</TargetFrameworks>
     <TargetFrameworks Condition="'$(IsWindows)'!='true'">netstandard1.5;netstandard2.0;netstandard2.1</TargetFrameworks>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>9</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarningsAsErrors />
     <CodeAnalysisRuleSet>..\..\MongoDBLegacy.ruleset</CodeAnalysisRuleSet>
diff --git a/src/MongoDB.Driver.Legacy/MongoServerSettings.cs b/src/MongoDB.Driver.Legacy/MongoServerSettings.cs
@@ -887,7 +887,7 @@ public static MongoServerSettings FromUrl(MongoUrl url)
             serverSettings.IPv6 = url.IPv6;
             serverSettings.MaxConnectionIdleTime = url.MaxConnectionIdleTime;
             serverSettings.MaxConnectionLifeTime = url.MaxConnectionLifeTime;
-            serverSettings.MaxConnectionPoolSize = url.MaxConnectionPoolSize;
+            serverSettings.MaxConnectionPoolSize = ConnectionStringConversions.GetEffectiveMaxConnections(url.MaxConnectionPoolSize);
             serverSettings.MinConnectionPoolSize = url.MinConnectionPoolSize;
             serverSettings.ReadConcern = new ReadConcern(url.ReadConcernLevel);
             serverSettings.ReadEncoding = null; // ReadEncoding must be provided in code
diff --git a/src/MongoDB.Driver/MongoClientSettings.cs b/src/MongoDB.Driver/MongoClientSettings.cs
@@ -448,7 +448,7 @@ public int MaxConnectionPoolSize
             set
             {
                 if (_isFrozen) { throw new InvalidOperationException("MongoClientSettings is frozen."); }
-                _maxConnectionPoolSize = value;
+                _maxConnectionPoolSize = Ensure.IsGreaterThanZero(value, nameof(MaxConnectionPoolSize));
             }
         }
 
@@ -871,7 +871,7 @@ public static MongoClientSettings FromUrl(MongoUrl url)
             clientSettings.IPv6 = url.IPv6;
             clientSettings.MaxConnectionIdleTime = url.MaxConnectionIdleTime;
             clientSettings.MaxConnectionLifeTime = url.MaxConnectionLifeTime;
-            clientSettings.MaxConnectionPoolSize = url.MaxConnectionPoolSize;
+            clientSettings.MaxConnectionPoolSize = ConnectionStringConversions.GetEffectiveMaxConnections(url.MaxConnectionPoolSize);
             clientSettings.MinConnectionPoolSize = url.MinConnectionPoolSize;
             clientSettings.ReadConcern = new ReadConcern(url.ReadConcernLevel);
             clientSettings.ReadEncoding = null; // ReadEncoding must be provided in code
diff --git a/src/MongoDB.Driver/MongoDB.Driver.csproj b/src/MongoDB.Driver/MongoDB.Driver.csproj
@@ -65,6 +65,7 @@
 
   <ItemGroup>
     <Compile Include="..\MongoDB.Shared\ApplicationNameHelper.cs" Link="ApplicationNameHelper.cs" />
+    <Compile Include="..\MongoDB.Shared\ConnectionStringConversions.cs" Link="Support\ConnectionStringConversions.cs" />
     <Compile Include="..\MongoDB.Shared\Hasher.cs" Link="Support\Hasher.cs" />
     <Compile Include="..\MongoDB.Shared\OperatingSystemHelper.cs" Link="Support\OperatingSystemHelper.cs" />
     <Compile Include="..\MongoDB.Shared\SecureStringHelper.cs" Link="Support\SecureStringHelper.cs" />
diff --git a/src/MongoDB.Driver/MongoDefaults.cs b/src/MongoDB.Driver/MongoDefaults.cs
@@ -18,6 +18,8 @@
 using System.Threading;
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
+using MongoDB.Driver.Core.Misc;
+using MongoDB.Shared;
 
 namespace MongoDB.Driver
 {
@@ -82,7 +84,7 @@ public static int ComputedWaitQueueSize
                 }
                 else
                 {
-                    return (int)(__waitQueueMultiple * __maxConnectionPoolSize);
+                    return ConnectionStringConversions.GetComputedWaitQueueSize(__maxConnectionPoolSize, __waitQueueMultiple);
                 }
             }
         }
@@ -150,7 +152,7 @@ public static TimeSpan MaxConnectionLifeTime
         public static int MaxConnectionPoolSize
         {
             get { return __maxConnectionPoolSize; }
-            set { __maxConnectionPoolSize = value; }
+            set { __maxConnectionPoolSize = Ensure.IsGreaterThanZero(value, nameof(MaxConnectionPoolSize)); }
         }
 
         /// <summary>
diff --git a/src/MongoDB.Driver/MongoUrl.cs b/src/MongoDB.Driver/MongoUrl.cs
@@ -21,6 +21,7 @@
 using MongoDB.Bson;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Configuration;
+using MongoDB.Shared;
 
 namespace MongoDB.Driver
 {
@@ -225,7 +226,8 @@ public int ComputedWaitQueueSize
                 }
                 else
                 {
-                    return (int)(_waitQueueMultiple * _maxConnectionPoolSize);
+                    var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(_maxConnectionPoolSize);
+                    return ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, _waitQueueMultiple);
                 }
             }
         }
diff --git a/src/MongoDB.Driver/MongoUrlBuilder.cs b/src/MongoDB.Driver/MongoUrlBuilder.cs
@@ -223,7 +223,8 @@ public int ComputedWaitQueueSize
                 }
                 else
                 {
-                    return (int)(_waitQueueMultiple * _maxConnectionPoolSize);
+                    var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(_maxConnectionPoolSize);
+                    return ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, _waitQueueMultiple);
                 }
             }
         }
@@ -460,9 +461,9 @@ public int MaxConnectionPoolSize
             get { return _maxConnectionPoolSize; }
             set
             {
-                if (value <= 0)
+                if (value < 0)
                 {
-                    throw new ArgumentOutOfRangeException("value", "MaxConnectionPoolSize must be greater than zero.");
+                    throw new ArgumentOutOfRangeException("value", "MaxConnectionPoolSize must be greater than or equal to zero.");
                 }
                 _maxConnectionPoolSize = value;
             }
diff --git a/src/MongoDB.Shared/ConnectionStringConversions.cs b/src/MongoDB.Shared/ConnectionStringConversions.cs
@@ -0,0 +1,69 @@
+/* Copyright 2020-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+
+namespace MongoDB.Shared
+{
+    internal static class ConnectionStringConversions
+    {
+        /// <summary>
+        /// Compute the wait queue size.
+        /// </summary>
+        /// <param name="effectiveMaxConnections">The max number of connections.</param>
+        /// <param name="multiplier">The multiplier.</param>
+        /// <returns>The computed wait queue size.</returns>
+        [Obsolete("This method will be removed in a later release.")]
+        public static int GetComputedWaitQueueSize(int effectiveMaxConnections, double multiplier)
+        {
+            if (effectiveMaxConnections == int.MaxValue)
+            {
+                return int.MaxValue;
+            }
+            else
+            {
+                var computedWaitQueueSize = effectiveMaxConnections * multiplier;
+                if (computedWaitQueueSize > int.MaxValue)
+                {
+                    return int.MaxValue;
+                }
+                else
+                {
+                    return (int)computedWaitQueueSize;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the effective max connections.
+        /// </summary>
+        /// <param name="maxConnections">The max connections (0 means no max).</param>
+        /// <returns>The effective max connections.</returns>
+        public static int GetEffectiveMaxConnections(int maxConnections)
+        {
+            return maxConnections == 0 ? int.MaxValue : maxConnections;
+        }
+
+        /// <summary>
+        /// Gets the effective max connections.
+        /// </summary>
+        /// <param name="maxConnections">The max connections (0 means no max).</param>
+        /// <returns>The effective max connections (or null if maxConnections is null).</returns>
+        public static int? GetEffectiveMaxConnections(int? maxConnections)
+        {
+            return maxConnections.HasValue ? GetEffectiveMaxConnections(maxConnections.Value) : (int?)null;
+        }
+    }
+}
diff --git a/tests/MongoDB.Driver.Core.Tests/Core/Configuration/ConnectionStringTests.cs b/tests/MongoDB.Driver.Core.Tests/Core/Configuration/ConnectionStringTests.cs
@@ -31,6 +31,26 @@ namespace MongoDB.Driver.Core.Configuration
     [Trait("Category", "ConnectionString")]
     public class ConnectionStringTests
     {
+        [Fact]
+        public void MaxPoolSize_zero_should_be_handled_correctly()
+        {
+            var subject = new ConnectionString("mongodb://localhost/?maxPoolSize=0");
+
+            var result = subject.MaxPoolSize;
+
+            result.Should().Be(0);
+        }
+
+        [Fact]
+        public void MaxPoolSize_missing_should_be_handled_correctly()
+        {
+            var subject = new ConnectionString("mongodb://localhost");
+
+            var result = subject.MaxPoolSize;
+
+            result.Should().Be(null);
+        }
+
         [Theory]
         [InlineData("mongodb://localhost", true)]
         [InlineData("mongodb+srv://localhost", false)]
diff --git a/tests/MongoDB.Driver.Core.Tests/Specifications/connection-string/ConnectionStringTestRunner.cs b/tests/MongoDB.Driver.Core.Tests/Specifications/connection-string/ConnectionStringTestRunner.cs
@@ -113,6 +113,12 @@ private void AssertOptions(ConnectionString connectionString, BsonDocument defin
                         case "maxidletimems":
                             AssertTimeSpan(connectionString.MaxIdleTime, expectedOption.Value);
                             break;
+                        case "minpoolsize":
+                            connectionString.MinPoolSize.Should().Be(expectedOption.Value.ToInt32());
+                            break;
+                        case "maxpoolsize":
+                            connectionString.MaxPoolSize.Should().Be(expectedOption.Value.ToInt32());
+                            break;
                         case "maxstalenessseconds":
                             AssertTimeSpan(connectionString.MaxStaleness, expectedOption.Value, false);
                             break;
diff --git a/tests/MongoDB.Driver.Core.Tests/Specifications/uri-options/tests/connection-pool-options.json b/tests/MongoDB.Driver.Core.Tests/Specifications/uri-options/tests/connection-pool-options.json
@@ -2,13 +2,15 @@
   "tests": [
     {
       "description": "Valid connection pool options are parsed correctly",
-      "uri": "mongodb://example.com/?maxIdleTimeMS=50000",
+      "uri": "mongodb://example.com/?maxIdleTimeMS=50000&maxPoolSize=5&minPoolSize=3",
       "valid": true,
       "warning": false,
       "hosts": null,
       "auth": null,
       "options": {
-        "maxIdleTimeMS": 50000
+        "maxIdleTimeMS": 50000,
+        "maxPoolSize": 5,
+        "minPoolSize": 3
       }
     },
     {
@@ -28,6 +30,28 @@
       "hosts": null,
       "auth": null,
       "options": {}
+    },
+    {
+      "description": "maxPoolSize=0 does not error",
+      "uri": "mongodb://example.com/?maxPoolSize=0",
+      "valid": true,
+      "warning": false,
+      "hosts": null,
+      "auth": null,
+      "options": {
+        "maxPoolSize": 0
+      }
+    },
+    {
+      "description": "minPoolSize=0 does not error",
+      "uri": "mongodb://example.com/?minPoolSize=0",
+      "valid": true,
+      "warning": false,
+      "hosts": null,
+      "auth": null,
+      "options": {
+        "minPoolSize": 0
+      }
     }
   ]
 }
diff --git a/tests/MongoDB.Driver.Core.Tests/Specifications/uri-options/tests/connection-pool-options.yml b/tests/MongoDB.Driver.Core.Tests/Specifications/uri-options/tests/connection-pool-options.yml
@@ -1,13 +1,15 @@
 tests:
     -
         description: "Valid connection pool options are parsed correctly"
-        uri: "mongodb://example.com/?maxIdleTimeMS=50000"
+        uri: "mongodb://example.com/?maxIdleTimeMS=50000&maxPoolSize=5&minPoolSize=3"
         valid: true
         warning: false
         hosts: ~
         auth: ~
         options:
             maxIdleTimeMS: 50000
+            maxPoolSize: 5
+            minPoolSize: 3
     -
         description: "Non-numeric maxIdleTimeMS causes a warning"
         uri: "mongodb://example.com/?maxIdleTimeMS=invalid"
@@ -24,3 +26,23 @@ tests:
         hosts: ~
         auth: ~
         options: {}
+
+    -
+      description: "maxPoolSize=0 does not error"
+      uri: "mongodb://example.com/?maxPoolSize=0"
+      valid: true
+      warning: false
+      hosts: ~
+      auth: ~
+      options:
+          maxPoolSize: 0
+
+    -
+      description: "minPoolSize=0 does not error"
+      uri: "mongodb://example.com/?minPoolSize=0"
+      valid: true
+      warning: false
+      hosts: ~
+      auth: ~
+      options:
+          minPoolSize: 0 
diff --git a/tests/MongoDB.Driver.Tests/MongoClientSettingsTests.cs b/tests/MongoDB.Driver.Tests/MongoClientSettingsTests.cs
diff --git a/tests/MongoDB.Driver.Tests/MongoUrlBuilderTests.cs b/tests/MongoDB.Driver.Tests/MongoUrlBuilderTests.cs
diff --git a/tests/MongoDB.Driver.Tests/MongoUrlTests.cs b/tests/MongoDB.Driver.Tests/MongoUrlTests.cs

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@`
`23`	`23`	`using MongoDB.Driver.Core.Clusters;`
`24`	`24`	`using MongoDB.Driver.Core.Events.Diagnostics;`
`25`	`25`	`using MongoDB.Driver.Core.Misc;`
	`26`	`+using MongoDB.Shared;`
`26`	`27`
`27`	`28`	`namespace MongoDB.Driver.Core.Configuration`
`28`	`29`	`{`
`@@ -182,7 +183,8 @@ public static ClusterBuilder ConfigureWithConnectionString(`
`182`	`183`	`// Connection Pool`
`183`	`184`	`if (connectionString.MaxPoolSize != null)`
`184`	`185`	`{`
`185`		`- builder = builder.ConfigureConnectionPool(s => s.With(maxConnections: connectionString.MaxPoolSize.Value));`
	`186`	`+ var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(connectionString.MaxPoolSize.Value);`
	`187`	`+ builder = builder.ConfigureConnectionPool(s => s.With(maxConnections: effectiveMaxConnections));`
`186`	`188`	`}`
`187`	`189`	`if (connectionString.MinPoolSize != null)`
`188`	`190`	`{`
`@@ -195,9 +197,9 @@ public static ClusterBuilder ConfigureWithConnectionString(`
`195`	`197`	`}`
`196`	`198`	`else if (connectionString.WaitQueueMultiple != null)`
`197`	`199`	`{`
`198`		`- var maxConnections = connectionString.MaxPoolSize ?? new ConnectionPoolSettings().MaxConnections;`
`199`		`- var waitQueueSize = (int)Math.Round(maxConnections * connectionString.WaitQueueMultiple.Value);`
`200`		`- builder = builder.ConfigureConnectionPool(s => s.With(waitQueueSize: waitQueueSize));`
	`200`	`+ var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(connectionString.MaxPoolSize) ?? new ConnectionPoolSettings().MaxConnections;`
	`201`	`+ var computedWaitQueueSize = ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, connectionString.WaitQueueMultiple.Value);`
	`202`	`+ builder = builder.ConfigureConnectionPool(s => s.With(waitQueueSize: computedWaitQueueSize));`
`201`	`203`	`}`
`202`	`204`	`#pragma warning restore 618`
`203`	`205`	`if (connectionString.WaitQueueTimeout != null)`
Original file line number	Diff line number	Diff line change
`@@ -448,7 +448,7 @@ public int MaxConnectionPoolSize`
`448`	`448`	`set`
`449`	`449`	`{`
`450`	`450`	`if (_isFrozen) { throw new InvalidOperationException("MongoClientSettings is frozen."); }`
`451`		`- _maxConnectionPoolSize = value;`
	`451`	`+ _maxConnectionPoolSize = Ensure.IsGreaterThanZero(value, nameof(MaxConnectionPoolSize));`
`452`	`452`	`}`
`453`	`453`	`}`
`454`	`454`
`@@ -871,7 +871,7 @@ public static MongoClientSettings FromUrl(MongoUrl url)`
`871`	`871`	`clientSettings.IPv6 = url.IPv6;`
`872`	`872`	`clientSettings.MaxConnectionIdleTime = url.MaxConnectionIdleTime;`
`873`	`873`	`clientSettings.MaxConnectionLifeTime = url.MaxConnectionLifeTime;`
`874`		`- clientSettings.MaxConnectionPoolSize = url.MaxConnectionPoolSize;`
	`874`	`+ clientSettings.MaxConnectionPoolSize = ConnectionStringConversions.GetEffectiveMaxConnections(url.MaxConnectionPoolSize);`
`875`	`875`	`clientSettings.MinConnectionPoolSize = url.MinConnectionPoolSize;`
`876`	`876`	`clientSettings.ReadConcern = new ReadConcern(url.ReadConcernLevel);`
`877`	`877`	`clientSettings.ReadEncoding = null; // ReadEncoding must be provided in code`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,8 @@`
`18`	`18`	`using System.Threading;`
`19`	`19`	`using MongoDB.Bson;`
`20`	`20`	`using MongoDB.Bson.IO;`
	`21`	`+using MongoDB.Driver.Core.Misc;`
	`22`	`+using MongoDB.Shared;`
`21`	`23`
`22`	`24`	`namespace MongoDB.Driver`
`23`	`25`	`{`
`@@ -82,7 +84,7 @@ public static int ComputedWaitQueueSize`
`82`	`84`	`}`
`83`	`85`	`else`
`84`	`86`	`{`
`85`		`- return (int)(__waitQueueMultiple * __maxConnectionPoolSize);`
	`87`	`+ return ConnectionStringConversions.GetComputedWaitQueueSize(__maxConnectionPoolSize, __waitQueueMultiple);`
`86`	`88`	`}`
`87`	`89`	`}`
`88`	`90`	`}`
`@@ -150,7 +152,7 @@ public static TimeSpan MaxConnectionLifeTime`
`150`	`152`	`public static int MaxConnectionPoolSize`
`151`	`153`	`{`
`152`	`154`	`get { return __maxConnectionPoolSize; }`
`153`		`- set { __maxConnectionPoolSize = value; }`
	`155`	`+ set { __maxConnectionPoolSize = Ensure.IsGreaterThanZero(value, nameof(MaxConnectionPoolSize)); }`
`154`	`156`	`}`
`155`	`157`
`156`	`158`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`using MongoDB.Bson;`
`22`	`22`	`using MongoDB.Driver.Core.Clusters;`
`23`	`23`	`using MongoDB.Driver.Core.Configuration;`
	`24`	`+using MongoDB.Shared;`
`24`	`25`
`25`	`26`	`namespace MongoDB.Driver`
`26`	`27`	`{`
`@@ -225,7 +226,8 @@ public int ComputedWaitQueueSize`
`225`	`226`	`}`
`226`	`227`	`else`
`227`	`228`	`{`
`228`		`- return (int)(_waitQueueMultiple * _maxConnectionPoolSize);`
	`229`	`+ var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(_maxConnectionPoolSize);`
	`230`	`+ return ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, _waitQueueMultiple);`
`229`	`231`	`}`
`230`	`232`	`}`
`231`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,8 @@ public int ComputedWaitQueueSize`
`223`	`223`	`}`
`224`	`224`	`else`
`225`	`225`	`{`
`226`		`- return (int)(_waitQueueMultiple * _maxConnectionPoolSize);`
	`226`	`+ var effectiveMaxConnections = ConnectionStringConversions.GetEffectiveMaxConnections(_maxConnectionPoolSize);`
	`227`	`+ return ConnectionStringConversions.GetComputedWaitQueueSize(effectiveMaxConnections, _waitQueueMultiple);`
`227`	`228`	`}`
`228`	`229`	`}`
`229`	`230`	`}`
`@@ -460,9 +461,9 @@ public int MaxConnectionPoolSize`
`460`	`461`	`get { return _maxConnectionPoolSize; }`
`461`	`462`	`set`
`462`	`463`	`{`
`463`		`- if (value <= 0)`
	`464`	`+ if (value < 0)`
`464`	`465`	`{`
`465`		`- throw new ArgumentOutOfRangeException("value", "MaxConnectionPoolSize must be greater than zero.");`
	`466`	`+ throw new ArgumentOutOfRangeException("value", "MaxConnectionPoolSize must be greater than or equal to zero.");`
`466`	`467`	`}`
`467`	`468`	`_maxConnectionPoolSize = value;`
`468`	`469`	`}`