Fix | Adding non-string support to SqlConnectionStringBuilder property indexer

doc/snippets/Microsoft.Data.SqlClient/SqlConnectionEncryptOption.xml

@@ -26,7 +26,7 @@ Implicit conversions have been added to maintain backwards compatibility with bo
     </Parse>
     <TryParse>
       <summary>
-        Converts the specified string representation of a logical value to its <see cref="T:Microsoft.Data.SqlClient.SqlConnectionEncryptOption"/> equivalent and returns a value that indicates whether the conversion succeeded.
+        Converts the specified string, boolean representation of a logical value to its <see cref="T:Microsoft.Data.SqlClient.SqlConnectionEncryptOption"/> equivalent and returns a value that indicates whether the conversion succeeded.
       </summary>
       <param name="value">A string containing the value to convert.</param>
       <param name="result">

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

@@ -816,10 +816,18 @@ internal static SqlConnectionEncryptOption ConvertToSqlConnectionEncryptOption(s
             {
                 return DbConnectionStringDefaults.Encrypt;
             }
+            else if(value is SqlConnectionEncryptOption eValue)
+            {
+                return eValue;
+            }
             else if (value is string sValue)
             {
                 return SqlConnectionEncryptOption.Parse(sValue);
             }
+            else if(value is bool bValue)
+            {
+                return SqlConnectionEncryptOption.Parse(bValue);
+            }
 
             throw ADP.InvalidConnectionOptionValue(keyword);
         }

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlConnectionEncryptOption.cs

@@ -43,6 +43,18 @@ public static SqlConnectionEncryptOption Parse(string value)
             }
         }
 
+        internal static SqlConnectionEncryptOption Parse(bool value)
+        {
+            if (TryParse(value, out SqlConnectionEncryptOption result))
+            {
+                return result;
+            }
+            else
+            {
+                throw ADP.InvalidConnectionOptionValue(SqlConnectionString.KEY.Encrypt);
+            }
+        }
+
         /// <include file='../../../../../../doc/snippets/Microsoft.Data.SqlClient/SqlConnectionEncryptOption.xml' path='docs/members[@name="SqlConnectionEncryptOption"]/TryParse/*' />
         public static bool TryParse(string value, out SqlConnectionEncryptOption result)
         {
@@ -73,6 +85,19 @@ public static bool TryParse(string value, out SqlConnectionEncryptOption result)
             }
         }
 
+        internal static bool TryParse(bool value, out SqlConnectionEncryptOption result)
+        {
+            switch(value)
+            {
+                case true:
+                    result = Mandatory;
+                    return true;
+                        case false:
+                    result = Optional;
+                    return true;
+            }
+        }
+
         /// <include file='../../../../../../doc/snippets/Microsoft.Data.SqlClient/SqlConnectionEncryptOption.xml' path='docs/members[@name="SqlConnectionEncryptOption"]/Optional/*' />
         public static SqlConnectionEncryptOption Optional => s_optional;
 

src/Microsoft.Data.SqlClient/tests/FunctionalTests/SqlConnectionStringBuilderTest.cs

@@ -253,7 +253,7 @@ public void SetInvalidPacketSize_Throws(int invalid)
         }
 
         [Theory]
-        [InlineData("AttachDBFilename","somefile.db")]
+        [InlineData("AttachDBFilename", "somefile.db")]
         public void SetKeyword(string keyword, string value)
         {
             SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
@@ -380,7 +380,7 @@ public void ConnectionBuilderEncryptBackwardsCompatibility()
             builder.Encrypt = false;
             Assert.Equal("Encrypt=False", builder.ConnectionString);
             Assert.False(builder.Encrypt);
-            
+
             builder.Encrypt = true;
             Assert.Equal("Encrypt=True", builder.ConnectionString);
             Assert.True(builder.Encrypt);
@@ -402,6 +402,25 @@ public void ConnectionBuilderEncryptBackwardsCompatibility()
             Assert.True(builder.Encrypt);
         }
 
+        [Fact]
+        public void EncryptParserValidValuesPropertyIndexerForEncryptionOption()
+        {
+            SqlConnectionStringBuilder builder = new();
+            try
+            {
+                builder["Encrypt"] = SqlConnectionEncryptOption.Strict;
+                CheckEncryptType(builder, SqlConnectionEncryptOption.Strict);
+                builder["Encrypt"] = SqlConnectionEncryptOption.Optional;
+                CheckEncryptType(builder, SqlConnectionEncryptOption.Optional);
+                builder["Encrypt"] = SqlConnectionEncryptOption.Mandatory;
+                CheckEncryptType(builder, SqlConnectionEncryptOption.Mandatory);
+            }
+            catch (SqlException ex)
+            {
+                Assert.Fail(ex.Message);
+            }
+        }
+
         [Theory]
         [InlineData("true", "True")]
         [InlineData("mandatory", "True")]
@@ -413,6 +432,30 @@ public void ConnectionBuilderEncryptBackwardsCompatibility()
         public void EncryptParserValidValuesParsesSuccessfully(string value, string expectedValue)
             => Assert.Equal(expectedValue, SqlConnectionEncryptOption.Parse(value).ToString());
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void EncryptParserValidValuesPropertyIndexerForBoolean(bool value)
+        {
+            SqlConnectionStringBuilder builder = new();
+            try
+            {
+                builder["Encrypt"] = value;
+                if(value == true)
+                {
+                    CheckEncryptType(builder, SqlConnectionEncryptOption.Mandatory);
+                }
+                else
+                {
+                    CheckEncryptType(builder, SqlConnectionEncryptOption.Optional);
+                }
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail(ex.Message);
+            }
+        }
+
         [Theory]
         [InlineData("something")]
         [InlineData("")]
@@ -467,5 +510,11 @@ internal void ExecuteConnectionStringTests(string connectionString)
                 Assert.NotNull(connection);
             }
         }
+
+        internal void CheckEncryptType(SqlConnectionStringBuilder builder, SqlConnectionEncryptOption expectedValue)
+        {
+            Assert.IsType<SqlConnectionEncryptOption>(builder.Encrypt);
+            Assert.Equal(expectedValue, builder.Encrypt);
+        }
     }
 }