Merge | DbConnectionString (#3416)

benrr101 · web-flow · commit 95253ac56895 · 2025-06-17T12:51:00.000-05:00
* Move DbConnectionString to the common project

# Conflicts:
#	src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj

* Remove DbConnectionString.KEY

* Rename DbConnectionString to match naming conventions
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj
@@ -258,6 +258,9 @@
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\Common\ConnectionString\DbConnectionStringSynonyms.cs">
       <Link>Microsoft\Data\Common\ConnectionString\DbConnectionStringSynonyms.cs</Link>
     </Compile>
+    <Compile Include="$(CommonSourceRoot)Microsoft\Data\Common\ConnectionString\DbConnectionString.netfx.cs">
+      <Link>Microsoft\Data\Common\ConnectionString\DbConnectionString.netfx.cs</Link>
+    </Compile>
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\Common\ConnectionString\DbConnectionStringUtilities.cs">
       <Link>Microsoft\Data\Common\ConnectionString\DbConnectionStringUtilities.cs</Link>
     </Compile>
@@ -948,9 +951,7 @@
     <Compile Include="$(CommonSourceRoot)System\IO\StreamExtensions.netfx.cs">
       <Link>System\IO\StreamExtensions.netfx.cs</Link>
     </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Microsoft\Data\Common\DBConnectionString.cs" />
+  
     <Compile Include="Microsoft\Data\SqlClient\SqlBulkCopy.cs" />
     <Compile Include="Microsoft\Data\SqlClient\SqlClientWrapperSmiStream.cs" />
     <Compile Include="Microsoft\Data\SqlClient\SqlClientWrapperSmiStreamChars.cs" />
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/ConnectionString/DbConnectionString.netfx.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/ConnectionString/DbConnectionString.netfx.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#if NETFRAMEWORK
+
 using System;
 using System.Collections.Generic;
 using System.Data;
@@ -12,21 +14,15 @@
 
 namespace Microsoft.Data.Common
 {
+    // @TODO: Theoretically this class could be replaced with SqlConnectionString.
+    
     [Serializable] // MDAC 83147
-    internal sealed class DBConnectionString
+    internal sealed class DbConnectionString
     {
         // instances of this class are intended to be immutable, i.e readonly
         // used by permission classes so it is much easier to verify correctness
         // when not worried about the class being modified during execution
 
-        // @TODO: Remove in favor of DbConnectionStringKeywords
-        private static class KEY
-        {
-            internal const string Password = DbConnectionStringKeywords.Password;
-            internal const string PersistSecurityInfo = DbConnectionStringKeywords.PersistSecurityInfo;
-            internal const string Pwd = DbConnectionStringSynonyms.Pwd;
-        };
-
         // this class is serializable with Everett, so ugly field names can't be changed
         readonly private string _encryptedUsersConnectionString;
 
@@ -51,21 +47,21 @@ private static class KEY
         readonly private string _encryptedActualConnectionString;
 #pragma warning restore 169
 
-        internal DBConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool useOdbcRules)
+        internal DbConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool useOdbcRules)
             : this(new DbConnectionOptions(value, synonyms), restrictions, behavior, synonyms, false)
         {
             // useOdbcRules is only used to parse the connection string, not to parse restrictions because values don't apply there
             // the hashtable doesn't need clone since it isn't shared with anything else
         }
 
-        internal DBConnectionString(DbConnectionOptions connectionOptions)
+        internal DbConnectionString(DbConnectionOptions connectionOptions)
             : this(connectionOptions, (string)null, KeyRestrictionBehavior.AllowOnly, null, true)
         {
-            // used by DBDataPermission to convert from DbConnectionOptions to DBConnectionString
+            // used by DBDataPermission to convert from DbConnectionOptions to DbConnectionString
             // since backward compatibility requires Everett level classes
         }
 
-        private DBConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool mustCloneDictionary)
+        private DbConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool mustCloneDictionary)
         { // used by DBDataPermission
             Debug.Assert(connectionOptions != null, "null connectionOptions");
             switch (behavior)
@@ -101,13 +97,13 @@ private DBConnectionString(DbConnectionOptions connectionOptions, string restric
                 // serialize out with '*' so already knows what we do.  Better this way
                 // than to treat password specially later on which causes problems.
                 const string star = "*";
-                if (_parsetable.ContainsKey(KEY.Password))
+                if (_parsetable.ContainsKey(DbConnectionStringKeywords.Password))
                 {
-                    _parsetable[KEY.Password] = star;
+                    _parsetable[DbConnectionStringKeywords.Password] = star;
                 }
-                if (_parsetable.ContainsKey(KEY.Pwd))
+                if (_parsetable.ContainsKey(DbConnectionStringSynonyms.Pwd))
                 {
-                    _parsetable[KEY.Pwd] = star;
+                    _parsetable[DbConnectionStringSynonyms.Pwd] = star;
                 }
 
                 // replace user's password/pwd value with "*" in the linked list and build a new string
@@ -121,7 +117,7 @@ private DBConnectionString(DbConnectionOptions connectionOptions, string restric
             }
         }
 
-        private DBConnectionString(DBConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior)
+        private DbConnectionString(DbConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior)
         {
             // used by intersect for two equal connection strings with different restrictions
             _encryptedUsersConnectionString = connectionString._encryptedUsersConnectionString;
@@ -198,7 +194,7 @@ internal bool ContainsKey(string keyword)
             return _parsetable.ContainsKey(keyword);
         }
 
-        internal DBConnectionString Intersect(DBConnectionString entry)
+        internal DbConnectionString Intersect(DbConnectionString entry)
         {
             KeyRestrictionBehavior behavior = _behavior;
             string[] restrictionValues = null;
@@ -287,18 +283,18 @@ internal DBConnectionString Intersect(DBConnectionString entry)
             }
 
             // verify _hasPassword & _parsetable are in sync between Everett/Whidbey
-            Debug.Assert(!_hasPassword || ContainsKey(KEY.Password) || ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");
-            Debug.Assert(entry == null || !entry._hasPassword || entry.ContainsKey(KEY.Password) || entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");
+            Debug.Assert(!_hasPassword || ContainsKey(DbConnectionStringKeywords.Password) || ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch this");
+            Debug.Assert(entry == null || !entry._hasPassword || entry.ContainsKey(DbConnectionStringKeywords.Password) || entry.ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch entry");
 
-            DBConnectionString value = new DBConnectionString(this, restrictionValues, behavior);
+            DbConnectionString value = new DbConnectionString(this, restrictionValues, behavior);
             ValidateCombinedSet(this, value);
             ValidateCombinedSet(entry, value);
 
             return value;
         }
 
         [Conditional("DEBUG")]
-        private void ValidateCombinedSet(DBConnectionString componentSet, DBConnectionString combinedSet)
+        private void ValidateCombinedSet(DbConnectionString componentSet, DbConnectionString combinedSet)
         {
             Debug.Assert(combinedSet != null, "The combined connection string should not be null");
             if ((componentSet != null) && (combinedSet._restrictionValues != null) && (componentSet._restrictionValues != null))
@@ -371,10 +367,10 @@ private bool IsRestrictedKeyword(string key)
             return (_restrictionValues == null || (0 > Array.BinarySearch(_restrictionValues, key, StringComparer.Ordinal)));
         }
 
-        internal bool IsSupersetOf(DBConnectionString entry)
+        internal bool IsSupersetOf(DbConnectionString entry)
         {
-            Debug.Assert(!_hasPassword || ContainsKey(KEY.Password) || ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");
-            Debug.Assert(!entry._hasPassword || entry.ContainsKey(KEY.Password) || entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");
+            Debug.Assert(!_hasPassword || ContainsKey(DbConnectionStringKeywords.Password) || ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch this");
+            Debug.Assert(!entry._hasPassword || entry.ContainsKey(DbConnectionStringKeywords.Password) || entry.ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch entry");
 
             switch (_behavior)
             {
@@ -481,10 +477,10 @@ static private string[] NoDuplicateUnion(string[] a, string[] b)
             return restrictionValues;
         }
 
-        private static string[] ParseRestrictions(string restrictions, Dictionary<string, string> synonyms)
+        private static string[] ParseRestrictions(string restrictions, IReadOnlyDictionary<string, string> synonyms)
         {
 #if DEBUG
-            SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DBConnectionString|INFO|ADV> Restrictions='{0}'", restrictions);
+            SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DbConnectionString|INFO|ADV> Restrictions='{0}'", restrictions);
 #endif
             List<string> restrictionValues = new List<string>();
             StringBuilder buffer = new StringBuilder(restrictions.Length);
@@ -500,7 +496,7 @@ private static string[] ParseRestrictions(string restrictions, Dictionary<string
                 if (!string.IsNullOrEmpty(keyname))
                 {
 #if DEBUG
-                    SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DBConnectionString|INFO|ADV> KeyName='{0}'", keyname);
+                    SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DbConnectionString|INFO|ADV> KeyName='{0}'", keyname);
 #endif
                     string realkeyname = synonyms != null ? (string)synonyms[keyname] : keyname; // MDAC 85144
                     if (string.IsNullOrEmpty(realkeyname))
@@ -568,3 +564,5 @@ private static void Verify(string[] restrictionValues)
         }
     }
 }
+
+#endif
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientPermission.netfx.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientPermission.netfx.cs
@@ -62,7 +62,7 @@ internal SqlClientPermission(SqlConnectionString constr) : base(PermissionState.
             if (constr != null)
             {
                 AllowBlankPassword = constr.HasBlankPassword; // MDAC 84563
-                AddPermissionEntry(new DBConnectionString(constr));
+                AddPermissionEntry(new DbConnectionString(constr));
             }
             
             if (constr == null || constr.IsEmpty)
@@ -106,7 +106,7 @@ private bool _IsUnrestricted
         /// <include file='../../../../../../doc/snippets/Microsoft.Data.SqlClient/SqlClientPermission.xml' path='docs/members[@name="SqlClientPermission"]/Add[@name="connectionStringAndrestrictionsStringAndBehavior"]/*' />
         public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
         {
-            DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);
+            DbConnectionString constr = new DbConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);
             AddPermissionEntry(constr);
         }
         
@@ -254,7 +254,7 @@ public override bool IsSubsetOf(IPermission target)
                     subset = true;
                     if (_keyvalues != null)
                     {
-                        foreach (DBConnectionString kventry in _keyvalues)
+                        foreach (DbConnectionString kventry in _keyvalues)
                         {
                             if (!superset._keyvaluetree.CheckValueForKeyPermit(kventry))
                             {
@@ -293,7 +293,7 @@ public override SecurityElement ToXml()
 
                 if (_keyvalues != null)
                 {
-                    foreach (DBConnectionString value in _keyvalues)
+                    foreach (DbConnectionString value in _keyvalues)
                     {
                         SecurityElement valueElement = new SecurityElement(XmlStr._add);
                         string tmp;
@@ -342,7 +342,7 @@ public override IPermission Union(IPermission target)
 
                 if (_keyvalues != null)
                 {
-                    foreach (DBConnectionString entry in _keyvalues)
+                    foreach (DbConnectionString entry in _keyvalues)
                     {
                         newPermission.AddPermissionEntry(entry);
                     }
@@ -352,7 +352,7 @@ public override IPermission Union(IPermission target)
             return newPermission.IsEmpty() ? null : newPermission;
         }
         
-        internal void AddPermissionEntry(DBConnectionString entry)
+        internal void AddPermissionEntry(DbConnectionString entry)
         {
             if (_keyvaluetree == null)
             {
@@ -407,7 +407,7 @@ private sealed class NameValuePermission : IComparable
             private readonly string _value;
 
             // value node with (_restrictions != null) are allowed to match connection strings
-            private DBConnectionString _entry;
+            private DbConnectionString _entry;
 
             private NameValuePermission[] _tree; // with branches
 
@@ -442,7 +442,7 @@ private NameValuePermission(string keyword)
                 _value = keyword;
             }
 
-            private NameValuePermission(string value, DBConnectionString entry)
+            private NameValuePermission(string value, DbConnectionString entry)
             {
                 _value = value;
                 _entry = entry;
@@ -451,9 +451,9 @@ private NameValuePermission(string value, DBConnectionString entry)
             int IComparable.CompareTo(object other) =>
                 string.CompareOrdinal(_value, ((NameValuePermission)other)._value);
 
-            internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBConnectionString entry)
+            internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DbConnectionString entry)
             {
-                Debug.Assert(entry != null, "null DBConnectionString");
+                Debug.Assert(entry != null, "null DbConnectionString");
 
                 if (entry.KeyChain != null)
                 {
@@ -471,7 +471,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC
                         kv = kvtree.CheckKeyForValue(keychain.Value);
                         if (kv == null)
                         {
-                            DBConnectionString insertValue = keychain.Next != null ? null : entry;
+                            DbConnectionString insertValue = keychain.Next != null ? null : entry;
                             kv = new NameValuePermission(keychain.Value, insertValue);
                             kvtree.Add(kv); // add directly into live tree
                             if (insertValue != null)
@@ -500,7 +500,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC
                 else
                 {
                     // global restrictions
-                    DBConnectionString kentry = kvtree._entry;
+                    DbConnectionString kentry = kvtree._entry;
                     if (kentry != null)
                     {
                         Debug.Assert(entries.Contains(kentry), "entries doesn't contain entry");
@@ -516,7 +516,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC
                 }
             }
 
-            internal bool CheckValueForKeyPermit(DBConnectionString parsetable)
+            internal bool CheckValueForKeyPermit(DbConnectionString parsetable)
             {
                 if (parsetable == null)
                 {
@@ -571,7 +571,7 @@ internal bool CheckValueForKeyPermit(DBConnectionString parsetable)
                     // partial chain match, either leaf-node by shorter chain or fail mid-chain if ( _restrictions == null)
                 }
 
-                DBConnectionString entry = _entry;
+                DbConnectionString entry = _entry;
                 if (entry != null)
                 {
                     // also checking !hasMatch is tempting, but wrong

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`	`// See the LICENSE file in the project root for more information.`
`4`	`4`
	`5`	`+#if NETFRAMEWORK`
	`6`	`+`
`5`	`7`	`using System;`
`6`	`8`	`using System.Collections.Generic;`
`7`	`9`	`using System.Data;`
`@@ -12,21 +14,15 @@`
`12`	`14`
`13`	`15`	`namespace Microsoft.Data.Common`
`14`	`16`	`{`
	`17`	`+ // @TODO: Theoretically this class could be replaced with SqlConnectionString.`
	`18`	`+`
`15`	`19`	`[Serializable] // MDAC 83147`
`16`		`- internal sealed class DBConnectionString`
	`20`	`+ internal sealed class DbConnectionString`
`17`	`21`	`{`
`18`	`22`	`// instances of this class are intended to be immutable, i.e readonly`
`19`	`23`	`// used by permission classes so it is much easier to verify correctness`
`20`	`24`	`// when not worried about the class being modified during execution`
`21`	`25`
`22`		`- // @TODO: Remove in favor of DbConnectionStringKeywords`
`23`		`- private static class KEY`
`24`		`- {`
`25`		`- internal const string Password = DbConnectionStringKeywords.Password;`
`26`		`- internal const string PersistSecurityInfo = DbConnectionStringKeywords.PersistSecurityInfo;`
`27`		`- internal const string Pwd = DbConnectionStringSynonyms.Pwd;`
`28`		`- };`
`29`		`-`
`30`	`26`	`// this class is serializable with Everett, so ugly field names can't be changed`
`31`	`27`	`readonly private string _encryptedUsersConnectionString;`
`32`	`28`
`@@ -51,21 +47,21 @@ private static class KEY`
`51`	`47`	`readonly private string _encryptedActualConnectionString;`
`52`	`48`	`#pragma warning restore 169`
`53`	`49`
`54`		`- internal DBConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool useOdbcRules)`
	`50`	`+ internal DbConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool useOdbcRules)`
`55`	`51`	`: this(new DbConnectionOptions(value, synonyms), restrictions, behavior, synonyms, false)`
`56`	`52`	`{`
`57`	`53`	`// useOdbcRules is only used to parse the connection string, not to parse restrictions because values don't apply there`
`58`	`54`	`// the hashtable doesn't need clone since it isn't shared with anything else`
`59`	`55`	`}`
`60`	`56`
`61`		`- internal DBConnectionString(DbConnectionOptions connectionOptions)`
	`57`	`+ internal DbConnectionString(DbConnectionOptions connectionOptions)`
`62`	`58`	`: this(connectionOptions, (string)null, KeyRestrictionBehavior.AllowOnly, null, true)`
`63`	`59`	`{`
`64`		`- // used by DBDataPermission to convert from DbConnectionOptions to DBConnectionString`
	`60`	`+ // used by DBDataPermission to convert from DbConnectionOptions to DbConnectionString`
`65`	`61`	`// since backward compatibility requires Everett level classes`
`66`	`62`	`}`
`67`	`63`
`68`		`- private DBConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool mustCloneDictionary)`
	`64`	`+ private DbConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Dictionary<string, string> synonyms, bool mustCloneDictionary)`
`69`	`65`	`{ // used by DBDataPermission`
`70`	`66`	`Debug.Assert(connectionOptions != null, "null connectionOptions");`
`71`	`67`	`switch (behavior)`
`@@ -101,13 +97,13 @@ private DBConnectionString(DbConnectionOptions connectionOptions, string restric`
`101`	`97`	`// serialize out with '*' so already knows what we do. Better this way`
`102`	`98`	`// than to treat password specially later on which causes problems.`
`103`	`99`	`const string star = "*";`
`104`		`- if (_parsetable.ContainsKey(KEY.Password))`
	`100`	`+ if (_parsetable.ContainsKey(DbConnectionStringKeywords.Password))`
`105`	`101`	`{`
`106`		`- _parsetable[KEY.Password] = star;`
	`102`	`+ _parsetable[DbConnectionStringKeywords.Password] = star;`
`107`	`103`	`}`
`108`		`- if (_parsetable.ContainsKey(KEY.Pwd))`
	`104`	`+ if (_parsetable.ContainsKey(DbConnectionStringSynonyms.Pwd))`
`109`	`105`	`{`
`110`		`- _parsetable[KEY.Pwd] = star;`
	`106`	`+ _parsetable[DbConnectionStringSynonyms.Pwd] = star;`
`111`	`107`	`}`
`112`	`108`
`113`	`109`	`// replace user's password/pwd value with "*" in the linked list and build a new string`
`@@ -121,7 +117,7 @@ private DBConnectionString(DbConnectionOptions connectionOptions, string restric`
`121`	`117`	`}`
`122`	`118`	`}`
`123`	`119`
`124`		`- private DBConnectionString(DBConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior)`
	`120`	`+ private DbConnectionString(DbConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior)`
`125`	`121`	`{`
`126`	`122`	`// used by intersect for two equal connection strings with different restrictions`
`127`	`123`	`_encryptedUsersConnectionString = connectionString._encryptedUsersConnectionString;`
`@@ -198,7 +194,7 @@ internal bool ContainsKey(string keyword)`
`198`	`194`	`return _parsetable.ContainsKey(keyword);`
`199`	`195`	`}`
`200`	`196`
`201`		`- internal DBConnectionString Intersect(DBConnectionString entry)`
	`197`	`+ internal DbConnectionString Intersect(DbConnectionString entry)`
`202`	`198`	`{`
`203`	`199`	`KeyRestrictionBehavior behavior = _behavior;`
`204`	`200`	`string[] restrictionValues = null;`
`@@ -287,18 +283,18 @@ internal DBConnectionString Intersect(DBConnectionString entry)`
`287`	`283`	`}`
`288`	`284`
`289`	`285`	`// verify _hasPassword & _parsetable are in sync between Everett/Whidbey`
`290`		`- Debug.Assert(!_hasPassword \|\| ContainsKey(KEY.Password) \|\| ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");`
`291`		`- Debug.Assert(entry == null \|\| !entry._hasPassword \|\| entry.ContainsKey(KEY.Password) \|\| entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");`
	`286`	`+ Debug.Assert(!_hasPassword \|\| ContainsKey(DbConnectionStringKeywords.Password) \|\| ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch this");`
	`287`	`+ Debug.Assert(entry == null \|\| !entry._hasPassword \|\| entry.ContainsKey(DbConnectionStringKeywords.Password) \|\| entry.ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch entry");`
`292`	`288`
`293`		`- DBConnectionString value = new DBConnectionString(this, restrictionValues, behavior);`
	`289`	`+ DbConnectionString value = new DbConnectionString(this, restrictionValues, behavior);`
`294`	`290`	`ValidateCombinedSet(this, value);`
`295`	`291`	`ValidateCombinedSet(entry, value);`
`296`	`292`
`297`	`293`	`return value;`
`298`	`294`	`}`
`299`	`295`
`300`	`296`	`[Conditional("DEBUG")]`
`301`		`- private void ValidateCombinedSet(DBConnectionString componentSet, DBConnectionString combinedSet)`
	`297`	`+ private void ValidateCombinedSet(DbConnectionString componentSet, DbConnectionString combinedSet)`
`302`	`298`	`{`
`303`	`299`	`Debug.Assert(combinedSet != null, "The combined connection string should not be null");`
`304`	`300`	`if ((componentSet != null) && (combinedSet._restrictionValues != null) && (componentSet._restrictionValues != null))`
`@@ -371,10 +367,10 @@ private bool IsRestrictedKeyword(string key)`
`371`	`367`	`return (_restrictionValues == null \|\| (0 > Array.BinarySearch(_restrictionValues, key, StringComparer.Ordinal)));`
`372`	`368`	`}`
`373`	`369`
`374`		`- internal bool IsSupersetOf(DBConnectionString entry)`
	`370`	`+ internal bool IsSupersetOf(DbConnectionString entry)`
`375`	`371`	`{`
`376`		`- Debug.Assert(!_hasPassword \|\| ContainsKey(KEY.Password) \|\| ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");`
`377`		`- Debug.Assert(!entry._hasPassword \|\| entry.ContainsKey(KEY.Password) \|\| entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");`
	`372`	`+ Debug.Assert(!_hasPassword \|\| ContainsKey(DbConnectionStringKeywords.Password) \|\| ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch this");`
	`373`	`+ Debug.Assert(!entry._hasPassword \|\| entry.ContainsKey(DbConnectionStringKeywords.Password) \|\| entry.ContainsKey(DbConnectionStringSynonyms.Pwd), "OnDeserialized password mismatch entry");`
`378`	`374`
`379`	`375`	`switch (_behavior)`
`380`	`376`	`{`
`@@ -481,10 +477,10 @@ static private string[] NoDuplicateUnion(string[] a, string[] b)`
`481`	`477`	`return restrictionValues;`
`482`	`478`	`}`
`483`	`479`
`484`		`- private static string[] ParseRestrictions(string restrictions, Dictionary<string, string> synonyms)`
	`480`	`+ private static string[] ParseRestrictions(string restrictions, IReadOnlyDictionary<string, string> synonyms)`
`485`	`481`	`{`
`486`	`482`	`#if DEBUG`
`487`		`- SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DBConnectionString\|INFO\|ADV> Restrictions='{0}'", restrictions);`
	`483`	`+ SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DbConnectionString\|INFO\|ADV> Restrictions='{0}'", restrictions);`
`488`	`484`	`#endif`
`489`	`485`	`List<string> restrictionValues = new List<string>();`
`490`	`486`	`StringBuilder buffer = new StringBuilder(restrictions.Length);`
`@@ -500,7 +496,7 @@ private static string[] ParseRestrictions(string restrictions, Dictionary<string`
`500`	`496`	`if (!string.IsNullOrEmpty(keyname))`
`501`	`497`	`{`
`502`	`498`	`#if DEBUG`
`503`		`- SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DBConnectionString\|INFO\|ADV> KeyName='{0}'", keyname);`
	`499`	`+ SqlClientEventSource.Log.TryAdvancedTraceEvent("<comm.DbConnectionString\|INFO\|ADV> KeyName='{0}'", keyname);`
`504`	`500`	`#endif`
`505`	`501`	`string realkeyname = synonyms != null ? (string)synonyms[keyname] : keyname; // MDAC 85144`
`506`	`502`	`if (string.IsNullOrEmpty(realkeyname))`
`@@ -568,3 +564,5 @@ private static void Verify(string[] restrictionValues)`
`568`	`564`	`}`
`569`	`565`	`}`
`570`	`566`	`}`
	`567`	`+`
	`568`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ internal SqlClientPermission(SqlConnectionString constr) : base(PermissionState.`
`62`	`62`	`if (constr != null)`
`63`	`63`	`{`
`64`	`64`	`AllowBlankPassword = constr.HasBlankPassword; // MDAC 84563`
`65`		`- AddPermissionEntry(new DBConnectionString(constr));`
	`65`	`+ AddPermissionEntry(new DbConnectionString(constr));`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`if (constr == null \|\| constr.IsEmpty)`
`@@ -106,7 +106,7 @@ private bool _IsUnrestricted`
`106`	`106`	`/// <include file='../../../../../../doc/snippets/Microsoft.Data.SqlClient/SqlClientPermission.xml' path='docs/members[@name="SqlClientPermission"]/Add[@name="connectionStringAndrestrictionsStringAndBehavior"]/*' />`
`107`	`107`	`public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)`
`108`	`108`	`{`
`109`		`- DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);`
	`109`	`+ DbConnectionString constr = new DbConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);`
`110`	`110`	`AddPermissionEntry(constr);`
`111`	`111`	`}`
`112`	`112`
`@@ -254,7 +254,7 @@ public override bool IsSubsetOf(IPermission target)`
`254`	`254`	`subset = true;`
`255`	`255`	`if (_keyvalues != null)`
`256`	`256`	`{`
`257`		`- foreach (DBConnectionString kventry in _keyvalues)`
	`257`	`+ foreach (DbConnectionString kventry in _keyvalues)`
`258`	`258`	`{`
`259`	`259`	`if (!superset._keyvaluetree.CheckValueForKeyPermit(kventry))`
`260`	`260`	`{`
`@@ -293,7 +293,7 @@ public override SecurityElement ToXml()`
`293`	`293`
`294`	`294`	`if (_keyvalues != null)`
`295`	`295`	`{`
`296`		`- foreach (DBConnectionString value in _keyvalues)`
	`296`	`+ foreach (DbConnectionString value in _keyvalues)`
`297`	`297`	`{`
`298`	`298`	`SecurityElement valueElement = new SecurityElement(XmlStr._add);`
`299`	`299`	`string tmp;`
`@@ -342,7 +342,7 @@ public override IPermission Union(IPermission target)`
`342`	`342`
`343`	`343`	`if (_keyvalues != null)`
`344`	`344`	`{`
`345`		`- foreach (DBConnectionString entry in _keyvalues)`
	`345`	`+ foreach (DbConnectionString entry in _keyvalues)`
`346`	`346`	`{`
`347`	`347`	`newPermission.AddPermissionEntry(entry);`
`348`	`348`	`}`
`@@ -352,7 +352,7 @@ public override IPermission Union(IPermission target)`
`352`	`352`	`return newPermission.IsEmpty() ? null : newPermission;`
`353`	`353`	`}`
`354`	`354`
`355`		`- internal void AddPermissionEntry(DBConnectionString entry)`
	`355`	`+ internal void AddPermissionEntry(DbConnectionString entry)`
`356`	`356`	`{`
`357`	`357`	`if (_keyvaluetree == null)`
`358`	`358`	`{`
`@@ -407,7 +407,7 @@ private sealed class NameValuePermission : IComparable`
`407`	`407`	`private readonly string _value;`
`408`	`408`
`409`	`409`	`// value node with (_restrictions != null) are allowed to match connection strings`
`410`		`- private DBConnectionString _entry;`
	`410`	`+ private DbConnectionString _entry;`
`411`	`411`
`412`	`412`	`private NameValuePermission[] _tree; // with branches`
`413`	`413`
`@@ -442,7 +442,7 @@ private NameValuePermission(string keyword)`
`442`	`442`	`_value = keyword;`
`443`	`443`	`}`
`444`	`444`
`445`		`- private NameValuePermission(string value, DBConnectionString entry)`
	`445`	`+ private NameValuePermission(string value, DbConnectionString entry)`
`446`	`446`	`{`
`447`	`447`	`_value = value;`
`448`	`448`	`_entry = entry;`
`@@ -451,9 +451,9 @@ private NameValuePermission(string value, DBConnectionString entry)`
`451`	`451`	`int IComparable.CompareTo(object other) =>`
`452`	`452`	`string.CompareOrdinal(_value, ((NameValuePermission)other)._value);`
`453`	`453`
`454`		`- internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBConnectionString entry)`
	`454`	`+ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DbConnectionString entry)`
`455`	`455`	`{`
`456`		`- Debug.Assert(entry != null, "null DBConnectionString");`
	`456`	`+ Debug.Assert(entry != null, "null DbConnectionString");`
`457`	`457`
`458`	`458`	`if (entry.KeyChain != null)`
`459`	`459`	`{`
`@@ -471,7 +471,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC`
`471`	`471`	`kv = kvtree.CheckKeyForValue(keychain.Value);`
`472`	`472`	`if (kv == null)`
`473`	`473`	`{`
`474`		`- DBConnectionString insertValue = keychain.Next != null ? null : entry;`
	`474`	`+ DbConnectionString insertValue = keychain.Next != null ? null : entry;`
`475`	`475`	`kv = new NameValuePermission(keychain.Value, insertValue);`
`476`	`476`	`kvtree.Add(kv); // add directly into live tree`
`477`	`477`	`if (insertValue != null)`
`@@ -500,7 +500,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC`
`500`	`500`	`else`
`501`	`501`	`{`
`502`	`502`	`// global restrictions`
`503`		`- DBConnectionString kentry = kvtree._entry;`
	`503`	`+ DbConnectionString kentry = kvtree._entry;`
`504`	`504`	`if (kentry != null)`
`505`	`505`	`{`
`506`	`506`	`Debug.Assert(entries.Contains(kentry), "entries doesn't contain entry");`
`@@ -516,7 +516,7 @@ internal static void AddEntry(NameValuePermission kvtree, ArrayList entries, DBC`
`516`	`516`	`}`
`517`	`517`	`}`
`518`	`518`
`519`		`- internal bool CheckValueForKeyPermit(DBConnectionString parsetable)`
	`519`	`+ internal bool CheckValueForKeyPermit(DbConnectionString parsetable)`
`520`	`520`	`{`
`521`	`521`	`if (parsetable == null)`
`522`	`522`	`{`
`@@ -571,7 +571,7 @@ internal bool CheckValueForKeyPermit(DBConnectionString parsetable)`
`571`	`571`	`// partial chain match, either leaf-node by shorter chain or fail mid-chain if ( _restrictions == null)`
`572`	`572`	`}`
`573`	`573`
`574`		`- DBConnectionString entry = _entry;`
	`574`	`+ DbConnectionString entry = _entry;`
`575`	`575`	`if (entry != null)`
`576`	`576`	`{`
`577`	`577`	`// also checking !hasMatch is tempting, but wrong`