Added PoolBlockingPeriod connection property

pkg/Microsoft.Private.PackageBaseline/packageIndex.json

@@ -2444,7 +2444,6 @@
     "System.Memory": {
       "InboxOn": {
         "netcoreapp2.1": "4.1.0.0",
-        "netcoreapp2.2": "4.1.0.0",
         "monoandroid10": "Any",
         "monotouch10": "Any",
         "uap10.0.16300": "4.1.0.0",
@@ -4980,7 +4979,6 @@
       "InboxOn": {
         "netcoreapp2.0": "4.1.1.0",
         "netcoreapp2.1": "4.3.0.0",
-        "netcoreapp2.2": "4.3.0.0",
         "uap10.0.16300": "4.3.0.0"
       },
       "AssemblyVersionInPackageVersion": {

src/System.Data.SqlClient/dir.props

@@ -2,7 +2,7 @@
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="..\dir.props" />
   <PropertyGroup>
-    <AssemblyVersion>4.4.1.0</AssemblyVersion>
+    <AssemblyVersion>4.5.0.0</AssemblyVersion>
     <AssemblyKey>MSFT</AssemblyKey>
     <IsUAP>true</IsUAP>
   </PropertyGroup>

src/System.Data.SqlClient/ref/System.Data.SqlClient.cs

@@ -283,6 +283,12 @@ public enum SortOrder
         Descending = 1,
         Unspecified = -1,
     }
+    public enum PoolBlockingPeriod
+    {
+        Auto = 0,
+        AlwaysBlock = 1,
+        NeverBlock = 2,
+    }
     public sealed partial class SqlBulkCopy : System.IDisposable
     {
         public SqlBulkCopy(System.Data.SqlClient.SqlConnection connection) { }
@@ -538,6 +544,7 @@ public override void Clear() { }
         public override bool Remove(string keyword) { throw null; }
         public override bool ShouldSerialize(string keyword) { throw null; }
         public override bool TryGetValue(string keyword, out object value) { throw null; }
+        public System.Data.SqlClient.PoolBlockingPeriod PoolBlockingPeriod { get { throw null; } set { } }
     }
     public sealed partial class SqlDataAdapter : System.Data.Common.DbDataAdapter, System.Data.IDbDataAdapter, System.ICloneable
     {

src/System.Data.SqlClient/src/System.Data.SqlClient.csproj

@@ -131,6 +131,7 @@
     <Compile Include="System\Data\SqlClient\ApplicationIntent.cs" />
     <Compile Include="System\Data\SqlClient\LocalDBAPI.cs" />
     <Compile Include="System\Data\SqlClient\ParameterPeekAheadValue.cs" />
+    <Compile Include="System\Data\SqlClient\PoolBlockingPeriod.cs" />
     <Compile Include="System\Data\SqlClient\RowsCopiedEventArgs.cs" />
     <Compile Include="System\Data\SqlClient\RowsCopiedEventHandler.cs" />
     <Compile Include="System\Data\SqlClient\SortOrder.cs" />

src/System.Data.SqlClient/src/System/Data/Common/DbConnectionStringCommon.cs

@@ -98,6 +98,142 @@ internal static string ConvertToString(object value)
                 throw ADP.ConvertFailed(value.GetType(), typeof(String), e);
             }
         }
+        #region <<PoolBlockingPeriod Utility>>
+        const string PoolBlockingPeriodAutoString = "Auto";
+        const string PoolBlockingPeriodAlwaysBlockString = "AlwaysBlock";
+        const string PoolBlockingPeriodNeverBlockString = "NeverBlock";
+
+        internal static bool TryConvertToPoolBlockingPeriod(string value, out PoolBlockingPeriod result)
+        {
+            Debug.Assert(Enum.GetNames(typeof(PoolBlockingPeriod)).Length == 3, "PoolBlockingPeriod enum has changed, update needed");
+            Debug.Assert(null != value, "TryConvertToPoolBlockingPeriod(null,...)");
+
+            if (StringComparer.OrdinalIgnoreCase.Equals(value, PoolBlockingPeriodAutoString))
+            {
+                result = PoolBlockingPeriod.Auto;
+                return true;
+            }
+            else if (StringComparer.OrdinalIgnoreCase.Equals(value, PoolBlockingPeriodAlwaysBlockString))
+            {
+                result = PoolBlockingPeriod.AlwaysBlock;
+                return true;
+            }
+            else if (StringComparer.OrdinalIgnoreCase.Equals(value, PoolBlockingPeriodNeverBlockString))
+            {
+                result = PoolBlockingPeriod.NeverBlock;
+                return true;
+            }
+            else
+            {
+                result = DbConnectionStringDefaults.PoolBlockingPeriod;
+                return false;
+            }
+        }
+
+        internal static bool IsValidPoolBlockingPeriodValue(PoolBlockingPeriod value)
+        {
+            Debug.Assert(Enum.GetNames(typeof(PoolBlockingPeriod)).Length == 3, "PoolBlockingPeriod enum has changed, update needed");
+            return value == PoolBlockingPeriod.Auto || value == PoolBlockingPeriod.AlwaysBlock || value == PoolBlockingPeriod.NeverBlock;
+        }
+
+        internal static string PoolBlockingPeriodToString(PoolBlockingPeriod value)
+        {
+            Debug.Assert(IsValidPoolBlockingPeriodValue(value));
+
+            if (value == PoolBlockingPeriod.AlwaysBlock)
+            {
+                return PoolBlockingPeriodAlwaysBlockString;
+            }
+            if (value == PoolBlockingPeriod.NeverBlock)
+            {
+                return PoolBlockingPeriodNeverBlockString;
+            }
+            else
+            {
+                return PoolBlockingPeriodAutoString;
+            }
+        }
+
+        /// <summary>
+        /// This method attempts to convert the given value to a PoolBlockingPeriod enum. The algorithm is:
+        /// * if the value is from type string, it will be matched against PoolBlockingPeriod enum names only, using ordinal, case-insensitive comparer
+        /// * if the value is from type PoolBlockingPeriod, it will be used as is
+        /// * if the value is from integral type (SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, or UInt64), it will be converted to enum
+        /// * if the value is another enum or any other type, it will be blocked with an appropriate ArgumentException
+        /// 
+        /// in any case above, if the conerted value is out of valid range, the method raises ArgumentOutOfRangeException.
+        /// </summary>
+        /// <returns>PoolBlockingPeriod value in the valid range</returns>
+        internal static PoolBlockingPeriod ConvertToPoolBlockingPeriod(string keyword, object value)
+        {
+            Debug.Assert(null != value, "ConvertToPoolBlockingPeriod(null)");
+            string sValue = (value as string);
+            PoolBlockingPeriod result;
+            if (null != sValue)
+            {
+                // We could use Enum.TryParse<PoolBlockingPeriod> here, but it accepts value combinations like
+                // "ReadOnly, ReadWrite" which are unwelcome here
+                // Also, Enum.TryParse is 100x slower than plain StringComparer.OrdinalIgnoreCase.Equals method.
+
+                if (TryConvertToPoolBlockingPeriod(sValue, out result))
+                {
+                    return result;
+                }
+
+                // try again after remove leading & trailing whitespaces.
+                sValue = sValue.Trim();
+                if (TryConvertToPoolBlockingPeriod(sValue, out result))
+                {
+                    return result;
+                }
+
+                // string values must be valid
+                throw ADP.InvalidConnectionOptionValue(keyword);
+            }
+            else
+            {
+                // the value is not string, try other options
+                PoolBlockingPeriod eValue;
+
+                if (value is PoolBlockingPeriod)
+                {
+                    // quick path for the most common case
+                    eValue = (PoolBlockingPeriod)value;
+                }
+                else if (value.GetType().IsEnum)
+                {
+                    // explicitly block scenarios in which user tries to use wrong enum types, like:
+                    // builder["PoolBlockingPeriod"] = EnvironmentVariableTarget.Process;
+                    // workaround: explicitly cast non-PoolBlockingPeriod enums to int
+                    throw ADP.ConvertFailed(value.GetType(), typeof(PoolBlockingPeriod), null);
+                }
+                else
+                {
+                    try
+                    {
+                        // Enum.ToObject allows only integral and enum values (enums are blocked above), rasing ArgumentException for the rest
+                        eValue = (PoolBlockingPeriod)Enum.ToObject(typeof(PoolBlockingPeriod), value);
+                    }
+                    catch (ArgumentException e)
+                    {
+                        // to be consistent with the messages we send in case of wrong type usage, replace 
+                        // the error with our exception, and keep the original one as inner one for troubleshooting
+                        throw ADP.ConvertFailed(value.GetType(), typeof(PoolBlockingPeriod), e);
+                    }
+                }
+
+                // ensure value is in valid range
+                if (IsValidPoolBlockingPeriodValue(eValue))
+                {
+                    return eValue;
+                }
+                else
+                {
+                    throw ADP.InvalidEnumerationValue(typeof(ApplicationIntent), (int)eValue);
+                }
+            }
+        }
+        #endregion
 
         private const string ApplicationIntentReadWriteString = "ReadWrite";
         private const string ApplicationIntentReadOnlyString = "ReadOnly";
@@ -259,6 +395,7 @@ internal static partial class DbConnectionStringDefaults
         internal const string TransactionBinding = "Implicit Unbind";
         internal const int ConnectRetryCount = 1;
         internal const int ConnectRetryInterval = 10;
+        internal const PoolBlockingPeriod PoolBlockingPeriod = SqlClient.PoolBlockingPeriod.Auto;
     }
 
 
@@ -306,6 +443,7 @@ internal static partial class DbConnectionStringKeywords
         internal const string MaxPoolSize = "Max Pool Size";
         internal const string Pooling = "Pooling";
         internal const string MinPoolSize = "Min Pool Size";
+        internal const string PoolBlockingPeriod = "PoolBlockingPeriod";
     }
 
     internal static class DbConnectionStringSynonyms

src/System.Data.SqlClient/src/System/Data/ProviderBase/DbConnectionPool.cs

@@ -8,6 +8,7 @@
 
 using System.Collections.Generic;
 using System.Data.Common;
+using System.Data.SqlClient;
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
@@ -668,6 +669,45 @@ private Timer CreateCleanupTimer() =>
                 _cleanupWait,
                 _cleanupWait);
 
+        private bool IsBlockingPeriodEnabled()
+        {
+            var poolGroupConnectionOptions = _connectionPoolGroup.ConnectionOptions as SqlConnectionString;
+            if (poolGroupConnectionOptions == null)
+            {
+                return true;
+            }
+            var policy = poolGroupConnectionOptions.PoolBlockingPeriod;
+
+            switch (policy)
+            {
+                case System.Data.SqlClient.PoolBlockingPeriod.Auto:
+                    {
+                        if (ADP.IsAzureSqlServerEndpoint(poolGroupConnectionOptions.DataSource))
+                        {
+                            return false; // in Azure it will be Disabled
+                        }
+                        else
+                        {
+                            return true; // in Non Azure, it will be Enabled
+                        }
+                    }
+                case System.Data.SqlClient.PoolBlockingPeriod.AlwaysBlock:
+                    {
+                        return true; //Enabled
+                    }
+                case System.Data.SqlClient.PoolBlockingPeriod.NeverBlock:
+                    {
+                        return false; //Disabled
+                    }
+                default:
+                    {
+                        //we should never get into this path.
+                        Debug.Fail("Unknown PoolBlockingPeriod. Please specify explicit results in above switch case statement.");
+                        return true;
+                    }
+            }
+        }
+
         private DbConnectionInternal CreateObject(DbConnection owningObject, DbConnectionOptions userOptions, DbConnectionInternal oldConnection)
         {
             DbConnectionInternal newObj = null;
@@ -719,6 +759,10 @@ private DbConnectionInternal CreateObject(DbConnection owningObject, DbConnectio
                 {
                     throw;
                 }
+                if (!IsBlockingPeriodEnabled())
+                {
+                    throw;
+                }
                 newObj = null; // set to null, so we do not return bad new object
                 // Failed to create instance
                 _resError = e;

src/System.Data.SqlClient/src/System/Data/SqlClient/PoolBlockingPeriod.cs

@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+
+namespace System.Data.SqlClient
+{
+    public enum PoolBlockingPeriod
+    {
+        Auto = 0,         // Blocking period OFF for Azure SQL servers, but ON for all other SQL servers.
+        AlwaysBlock = 1,  // Blocking period ON for all SQL servers including Azure SQL servers.    
+        NeverBlock = 2,   // Blocking period OFF for all SQL servers including Azure SQL servers.
+    }
+}

src/System.Data.SqlClient/src/System/Data/SqlClient/SqlConnection.cs

@@ -209,6 +209,11 @@ internal Version TypeSystemAssemblyVersion
             get => ((SqlConnectionString)ConnectionOptions).TypeSystemAssemblyVersion;
         }
 
+        internal PoolBlockingPeriod PoolBlockingPeriod
+        {
+            get => ((SqlConnectionString)ConnectionOptions).PoolBlockingPeriod;
+        }
+
         internal int ConnectRetryInterval
         {
             get => ((SqlConnectionString)ConnectionOptions).ConnectRetryInterval;