[dotnet] Add nullability annotations to Proxy

RenderMichael · RenderMichael · commit 1187d12d8fb4 · 2024-12-06T01:08:11.000-05:00
diff --git a/dotnet/src/webdriver/Proxy.cs b/dotnet/src/webdriver/Proxy.cs
@@ -23,6 +23,8 @@
 using System.Globalization;
 using System.Text.Json.Serialization;
 
+#nullable enable
+
 namespace OpenQA.Selenium
 {
     /// <summary>
@@ -72,13 +74,13 @@ public class Proxy
     {
         private ProxyKind proxyKind = ProxyKind.Unspecified;
         private bool isAutoDetect;
-        private string ftpProxyLocation;
-        private string httpProxyLocation;
-        private string proxyAutoConfigUrl;
-        private string sslProxyLocation;
-        private string socksProxyLocation;
-        private string socksUserName;
-        private string socksPassword;
+        private string? ftpProxyLocation;
+        private string? httpProxyLocation;
+        private string? proxyAutoConfigUrl;
+        private string? sslProxyLocation;
+        private string? socksProxyLocation;
+        private string? socksUserName;
+        private string? socksPassword;
         private int? socksVersion;
         private List<string> noProxyAddresses = new List<string>();
 
@@ -93,93 +95,90 @@ public Proxy()
         /// Initializes a new instance of the <see cref="Proxy"/> class with the given proxy settings.
         /// </summary>
         /// <param name="settings">A dictionary of settings to use with the proxy.</param>
+        /// <exception cref="ArgumentNullException">If <paramref name="settings"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">If The "noProxy" value is a list with a <see langword="null"/> element.</exception>
         public Proxy(Dictionary<string, object> settings)
         {
             if (settings == null)
             {
                 throw new ArgumentNullException(nameof(settings), "settings dictionary cannot be null");
             }
 
-            if (settings.ContainsKey("proxyType") && settings["proxyType"] != null)
+            if (settings.TryGetValue("proxyType", out object? proxyTypeObj) && proxyTypeObj?.ToString() is string proxyType)
             {
                 // Special-case "PAC" since that is the correct serialization.
-                if (settings["proxyType"].ToString().ToLowerInvariant() == "pac")
+                if (proxyType.Equals("pac", StringComparison.InvariantCultureIgnoreCase))
                 {
                     this.Kind = ProxyKind.ProxyAutoConfigure;
                 }
                 else
                 {
-                    ProxyKind rawType = (ProxyKind)Enum.Parse(typeof(ProxyKind), settings["proxyType"].ToString(), true);
+                    ProxyKind rawType = Enum.Parse<ProxyKind>(proxyType, ignoreCase: true);
                     this.Kind = rawType;
                 }
             }
 
-            if (settings.ContainsKey("ftpProxy") && settings["ftpProxy"] != null)
+            if (settings.TryGetValue("ftpProxy", out object? ftpProxyObj) && ftpProxyObj?.ToString() is string ftpProxy)
             {
-                this.FtpProxy = settings["ftpProxy"].ToString();
+                this.FtpProxy = ftpProxy;
             }
 
-            if (settings.ContainsKey("httpProxy") && settings["httpProxy"] != null)
+            if (settings.TryGetValue("httpProxy", out object? httpProxyObj) && httpProxyObj?.ToString() is string httpProxy)
             {
-                this.HttpProxy = settings["httpProxy"].ToString();
+                this.HttpProxy = httpProxy;
             }
 
-            if (settings.ContainsKey("noProxy") && settings["noProxy"] != null)
+            if (settings.TryGetValue("noProxy", out object? noProxy) && noProxy != null)
             {
                 List<string> bypassAddresses = new List<string>();
-                string addressesAsString = settings["noProxy"] as string;
-                if (addressesAsString != null)
+                if (noProxy is string addressesAsString)
                 {
                     bypassAddresses.AddRange(addressesAsString.Split(';'));
                 }
-                else
+                else if (noProxy is object?[]  addressesAsArray)
                 {
-                    object[] addressesAsArray = settings["noProxy"] as object[];
-                    if (addressesAsArray != null)
+                    foreach (object? address in addressesAsArray)
                     {
-                        foreach (object address in addressesAsArray)
-                        {
-                            bypassAddresses.Add(address.ToString());
-                        }
+                        bypassAddresses.Add(address?.ToString() ?? throw new ArgumentException("noProxy list contained null element", nameof(settings)));
                     }
                 }
 
                 this.AddBypassAddresses(bypassAddresses);
             }
 
-            if (settings.ContainsKey("proxyAutoconfigUrl") && settings["proxyAutoconfigUrl"] != null)
+            if (settings.TryGetValue("proxyAutoconfigUrl", out object? proxyAutoconfigUrlObj) && proxyAutoconfigUrlObj?.ToString() is string proxyAutoconfigUrl)
             {
-                this.ProxyAutoConfigUrl = settings["proxyAutoconfigUrl"].ToString();
+                this.ProxyAutoConfigUrl = proxyAutoconfigUrl;
             }
 
-            if (settings.ContainsKey("sslProxy") && settings["sslProxy"] != null)
+            if (settings.TryGetValue("sslProxy", out object? sslProxyObj) && sslProxyObj?.ToString() is string sslProxy)
             {
-                this.SslProxy = settings["sslProxy"].ToString();
+                this.SslProxy = sslProxy;
             }
 
-            if (settings.ContainsKey("socksProxy") && settings["socksProxy"] != null)
+            if (settings.TryGetValue("socksProxy", out object? socksProxyObj) && socksProxyObj?.ToString() is string socksProxy)
             {
-                this.SocksProxy = settings["socksProxy"].ToString();
+                this.SocksProxy = socksProxy;
             }
 
-            if (settings.ContainsKey("socksUsername") && settings["socksUsername"] != null)
+            if (settings.TryGetValue("socksUsername", out object? socksUsernameObj) && socksUsernameObj?.ToString() is string socksUsername)
             {
-                this.SocksUserName = settings["socksUsername"].ToString();
+                this.SocksUserName = socksUsername;
             }
 
-            if (settings.ContainsKey("socksPassword") && settings["socksPassword"] != null)
+            if (settings.TryGetValue("socksPassword", out object? socksPasswordObj) && socksPasswordObj?.ToString() is string socksPassword)
             {
-                this.SocksPassword = settings["socksPassword"].ToString();
+                this.SocksPassword = socksPassword;
             }
 
-            if (settings.ContainsKey("socksVersion") && settings["socksVersion"] != null)
+            if (settings.TryGetValue("socksVersion", out object? socksVersion) && socksVersion != null)
             {
-                this.SocksVersion = Convert.ToInt32(settings["socksVersion"]);
+                this.SocksVersion = Convert.ToInt32(socksVersion);
             }
 
-            if (settings.ContainsKey("autodetect") && settings["autodetect"] != null)
+            if (settings.TryGetValue("autodetect", out object? autodetect) && autodetect != null)
             {
-                this.IsAutoDetect = (bool)settings["autodetect"];
+                this.IsAutoDetect = Convert.ToBoolean(autodetect);
             }
         }
 
@@ -189,10 +188,7 @@ public Proxy(Dictionary<string, object> settings)
         [JsonIgnore]
         public ProxyKind Kind
         {
-            get
-            {
-                return this.proxyKind;
-            }
+            get => this.proxyKind;
 
             set
             {
@@ -224,10 +220,7 @@ public string SerializableProxyKind
         [JsonIgnore]
         public bool IsAutoDetect
         {
-            get
-            {
-                return this.isAutoDetect;
-            }
+            get => this.isAutoDetect;
 
             set
             {
@@ -247,12 +240,9 @@ public bool IsAutoDetect
         /// </summary>
         [JsonPropertyName("ftpProxy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string FtpProxy
+        public string? FtpProxy
         {
-            get
-            {
-                return this.ftpProxyLocation;
-            }
+            get => this.ftpProxyLocation;
 
             set
             {
@@ -267,12 +257,9 @@ public string FtpProxy
         /// </summary>
         [JsonPropertyName("httpProxy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string HttpProxy
+        public string? HttpProxy
         {
-            get
-            {
-                return this.httpProxyLocation;
-            }
+            get => this.httpProxyLocation;
 
             set
             {
@@ -287,7 +274,7 @@ public string HttpProxy
         /// </summary>
         [JsonPropertyName("noProxy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public ReadOnlyCollection<string> BypassProxyAddresses
+        public ReadOnlyCollection<string>? BypassProxyAddresses
         {
             get
             {
@@ -305,12 +292,9 @@ public ReadOnlyCollection<string> BypassProxyAddresses
         /// </summary>
         [JsonPropertyName("proxyAutoconfigUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string ProxyAutoConfigUrl
+        public string? ProxyAutoConfigUrl
         {
-            get
-            {
-                return this.proxyAutoConfigUrl;
-            }
+            get => this.proxyAutoConfigUrl;
 
             set
             {
@@ -325,12 +309,9 @@ public string ProxyAutoConfigUrl
         /// </summary>
         [JsonPropertyName("sslProxy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string SslProxy
+        public string? SslProxy
         {
-            get
-            {
-                return this.sslProxyLocation;
-            }
+            get => this.sslProxyLocation;
 
             set
             {
@@ -345,12 +326,9 @@ public string SslProxy
         /// </summary>
         [JsonPropertyName("socksProxy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string SocksProxy
+        public string? SocksProxy
         {
-            get
-            {
-                return this.socksProxyLocation;
-            }
+            get => this.socksProxyLocation;
 
             set
             {
@@ -365,12 +343,9 @@ public string SocksProxy
         /// </summary>
         [JsonPropertyName("socksUsername")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string SocksUserName
+        public string? SocksUserName
         {
-            get
-            {
-                return this.socksUserName;
-            }
+            get => this.socksUserName;
 
             set
             {
@@ -388,10 +363,7 @@ public string SocksUserName
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
         public int? SocksVersion
         {
-            get
-            {
-                return this.socksVersion;
-            }
+            get => this.socksVersion;
 
             set
             {
@@ -403,7 +375,7 @@ public int? SocksVersion
                 {
                     if (value.Value <= 0)
                     {
-                        throw new ArgumentException("SocksVersion must be a positive integer");
+                        throw new ArgumentOutOfRangeException(nameof(value), "SocksVersion must be a positive integer");
                     }
 
                     this.VerifyProxyTypeCompatilibily(ProxyKind.Manual);
@@ -418,12 +390,9 @@ public int? SocksVersion
         /// </summary>
         [JsonPropertyName("socksPassword")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
-        public string SocksPassword
+        public string? SocksPassword
         {
-            get
-            {
-                return this.socksPassword;
-            }
+            get => this.socksPassword;
 
             set
             {
@@ -453,7 +422,7 @@ public void AddBypassAddress(string address)
         /// <param name="addressesToAdd">An array of addresses to add.</param>
         public void AddBypassAddresses(params string[] addressesToAdd)
         {
-            this.AddBypassAddresses(new List<string>(addressesToAdd));
+            this.AddBypassAddresses((IEnumerable<string>)addressesToAdd);
         }
 
         /// <summary>
@@ -478,7 +447,7 @@ public void AddBypassAddresses(IEnumerable<string> addressesToAdd)
         /// </summary>
         /// <returns>A dictionary suitable for serializing to the W3C Specification
         /// dialect of the wire protocol.</returns>
-        internal Dictionary<string, object> ToCapability()
+        internal Dictionary<string, object?>? ToCapability()
         {
             return this.AsDictionary(true);
         }
@@ -489,17 +458,17 @@ internal Dictionary<string, object> ToCapability()
         /// </summary>
         /// <returns>A dictionary suitable for serializing to the OSS dialect of the
         /// wire protocol.</returns>
-        internal Dictionary<string, object> ToLegacyCapability()
+        internal Dictionary<string, object?>? ToLegacyCapability()
         {
             return this.AsDictionary(false);
         }
 
-        private Dictionary<string, object> AsDictionary(bool isSpecCompliant)
+        private Dictionary<string, object?>? AsDictionary(bool isSpecCompliant)
         {
-            Dictionary<string, object> serializedDictionary = null;
+            Dictionary<string, object?>? serializedDictionary = null;
             if (this.proxyKind != ProxyKind.Unspecified)
             {
-                serializedDictionary = new Dictionary<string, object>();
+                serializedDictionary = new Dictionary<string, object?>();
                 if (this.proxyKind == ProxyKind.ProxyAutoConfigure)
                 {
                     serializedDictionary["proxyType"] = "pac";
@@ -556,17 +525,12 @@ private Dictionary<string, object> AsDictionary(bool isSpecCompliant)
             return serializedDictionary;
         }
 
-        private object GetNoProxyAddressList(bool isSpecCompliant)
+        private object? GetNoProxyAddressList(bool isSpecCompliant)
         {
-            object addresses = null;
+            object? addresses = null;
             if (isSpecCompliant)
             {
-                List<object> addressList = new List<object>();
-                foreach (string address in this.noProxyAddresses)
-                {
-                    addressList.Add(address);
-                }
-
+                List<object> addressList = [.. this.noProxyAddresses];
                 addresses = addressList;
             }
             else

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,8 @@`
`23`	`23`	`using System.Globalization;`
`24`	`24`	`using System.Text.Json.Serialization;`
`25`	`25`
	`26`	`+#nullable enable`
	`27`	`+`
`26`	`28`	`namespace OpenQA.Selenium`
`27`	`29`	`{`
`28`	`30`	`/// <summary>`
`@@ -72,13 +74,13 @@ public class Proxy`
`72`	`74`	`{`
`73`	`75`	`private ProxyKind proxyKind = ProxyKind.Unspecified;`
`74`	`76`	`private bool isAutoDetect;`
`75`		`- private string ftpProxyLocation;`
`76`		`- private string httpProxyLocation;`
`77`		`- private string proxyAutoConfigUrl;`
`78`		`- private string sslProxyLocation;`
`79`		`- private string socksProxyLocation;`
`80`		`- private string socksUserName;`
`81`		`- private string socksPassword;`
	`77`	`+ private string? ftpProxyLocation;`
	`78`	`+ private string? httpProxyLocation;`
	`79`	`+ private string? proxyAutoConfigUrl;`
	`80`	`+ private string? sslProxyLocation;`
	`81`	`+ private string? socksProxyLocation;`
	`82`	`+ private string? socksUserName;`
	`83`	`+ private string? socksPassword;`
`82`	`84`	`private int? socksVersion;`
`83`	`85`	`private List<string> noProxyAddresses = new List<string>();`
`84`	`86`
`@@ -93,93 +95,90 @@ public Proxy()`
`93`	`95`	`/// Initializes a new instance of the <see cref="Proxy"/> class with the given proxy settings.`
`94`	`96`	`/// </summary>`
`95`	`97`	`/// <param name="settings">A dictionary of settings to use with the proxy.</param>`
	`98`	`+ /// <exception cref="ArgumentNullException">If <paramref name="settings"/> is <see langword="null"/>.</exception>`
	`99`	`+ /// <exception cref="ArgumentException">If The "noProxy" value is a list with a <see langword="null"/> element.</exception>`
`96`	`100`	`public Proxy(Dictionary<string, object> settings)`
`97`	`101`	`{`
`98`	`102`	`if (settings == null)`
`99`	`103`	`{`
`100`	`104`	`throw new ArgumentNullException(nameof(settings), "settings dictionary cannot be null");`
`101`	`105`	`}`
`102`	`106`
`103`		`- if (settings.ContainsKey("proxyType") && settings["proxyType"] != null)`
	`107`	`+ if (settings.TryGetValue("proxyType", out object? proxyTypeObj) && proxyTypeObj?.ToString() is string proxyType)`
`104`	`108`	`{`
`105`	`109`	`// Special-case "PAC" since that is the correct serialization.`
`106`		`- if (settings["proxyType"].ToString().ToLowerInvariant() == "pac")`
	`110`	`+ if (proxyType.Equals("pac", StringComparison.InvariantCultureIgnoreCase))`
`107`	`111`	`{`
`108`	`112`	`this.Kind = ProxyKind.ProxyAutoConfigure;`
`109`	`113`	`}`
`110`	`114`	`else`
`111`	`115`	`{`
`112`		`- ProxyKind rawType = (ProxyKind)Enum.Parse(typeof(ProxyKind), settings["proxyType"].ToString(), true);`
	`116`	`+ ProxyKind rawType = Enum.Parse<ProxyKind>(proxyType, ignoreCase: true);`
`113`	`117`	`this.Kind = rawType;`
`114`	`118`	`}`
`115`	`119`	`}`
`116`	`120`
`117`		`- if (settings.ContainsKey("ftpProxy") && settings["ftpProxy"] != null)`
	`121`	`+ if (settings.TryGetValue("ftpProxy", out object? ftpProxyObj) && ftpProxyObj?.ToString() is string ftpProxy)`
`118`	`122`	`{`
`119`		`- this.FtpProxy = settings["ftpProxy"].ToString();`
	`123`	`+ this.FtpProxy = ftpProxy;`
`120`	`124`	`}`
`121`	`125`
`122`		`- if (settings.ContainsKey("httpProxy") && settings["httpProxy"] != null)`
	`126`	`+ if (settings.TryGetValue("httpProxy", out object? httpProxyObj) && httpProxyObj?.ToString() is string httpProxy)`
`123`	`127`	`{`
`124`		`- this.HttpProxy = settings["httpProxy"].ToString();`
	`128`	`+ this.HttpProxy = httpProxy;`
`125`	`129`	`}`
`126`	`130`
`127`		`- if (settings.ContainsKey("noProxy") && settings["noProxy"] != null)`
	`131`	`+ if (settings.TryGetValue("noProxy", out object? noProxy) && noProxy != null)`
`128`	`132`	`{`
`129`	`133`	`List<string> bypassAddresses = new List<string>();`
`130`		`- string addressesAsString = settings["noProxy"] as string;`
`131`		`- if (addressesAsString != null)`
	`134`	`+ if (noProxy is string addressesAsString)`
`132`	`135`	`{`
`133`	`136`	`bypassAddresses.AddRange(addressesAsString.Split(';'));`
`134`	`137`	`}`
`135`		`- else`
	`138`	`+ else if (noProxy is object?[] addressesAsArray)`
`136`	`139`	`{`
`137`		`- object[] addressesAsArray = settings["noProxy"] as object[];`
`138`		`- if (addressesAsArray != null)`
	`140`	`+ foreach (object? address in addressesAsArray)`
`139`	`141`	`{`
`140`		`- foreach (object address in addressesAsArray)`
`141`		`- {`
`142`		`- bypassAddresses.Add(address.ToString());`
`143`		`- }`
	`142`	`+ bypassAddresses.Add(address?.ToString() ?? throw new ArgumentException("noProxy list contained null element", nameof(settings)));`
`144`	`143`	`}`
`145`	`144`	`}`
`146`	`145`
`147`	`146`	`this.AddBypassAddresses(bypassAddresses);`
`148`	`147`	`}`
`149`	`148`
`150`		`- if (settings.ContainsKey("proxyAutoconfigUrl") && settings["proxyAutoconfigUrl"] != null)`
	`149`	`+ if (settings.TryGetValue("proxyAutoconfigUrl", out object? proxyAutoconfigUrlObj) && proxyAutoconfigUrlObj?.ToString() is string proxyAutoconfigUrl)`
`151`	`150`	`{`
`152`		`- this.ProxyAutoConfigUrl = settings["proxyAutoconfigUrl"].ToString();`
	`151`	`+ this.ProxyAutoConfigUrl = proxyAutoconfigUrl;`
`153`	`152`	`}`
`154`	`153`
`155`		`- if (settings.ContainsKey("sslProxy") && settings["sslProxy"] != null)`
	`154`	`+ if (settings.TryGetValue("sslProxy", out object? sslProxyObj) && sslProxyObj?.ToString() is string sslProxy)`
`156`	`155`	`{`
`157`		`- this.SslProxy = settings["sslProxy"].ToString();`
	`156`	`+ this.SslProxy = sslProxy;`
`158`	`157`	`}`
`159`	`158`
`160`		`- if (settings.ContainsKey("socksProxy") && settings["socksProxy"] != null)`
	`159`	`+ if (settings.TryGetValue("socksProxy", out object? socksProxyObj) && socksProxyObj?.ToString() is string socksProxy)`
`161`	`160`	`{`
`162`		`- this.SocksProxy = settings["socksProxy"].ToString();`
	`161`	`+ this.SocksProxy = socksProxy;`
`163`	`162`	`}`
`164`	`163`
`165`		`- if (settings.ContainsKey("socksUsername") && settings["socksUsername"] != null)`
	`164`	`+ if (settings.TryGetValue("socksUsername", out object? socksUsernameObj) && socksUsernameObj?.ToString() is string socksUsername)`
`166`	`165`	`{`
`167`		`- this.SocksUserName = settings["socksUsername"].ToString();`
	`166`	`+ this.SocksUserName = socksUsername;`
`168`	`167`	`}`
`169`	`168`
`170`		`- if (settings.ContainsKey("socksPassword") && settings["socksPassword"] != null)`
	`169`	`+ if (settings.TryGetValue("socksPassword", out object? socksPasswordObj) && socksPasswordObj?.ToString() is string socksPassword)`
`171`	`170`	`{`
`172`		`- this.SocksPassword = settings["socksPassword"].ToString();`
	`171`	`+ this.SocksPassword = socksPassword;`
`173`	`172`	`}`
`174`	`173`
`175`		`- if (settings.ContainsKey("socksVersion") && settings["socksVersion"] != null)`
	`174`	`+ if (settings.TryGetValue("socksVersion", out object? socksVersion) && socksVersion != null)`
`176`	`175`	`{`
`177`		`- this.SocksVersion = Convert.ToInt32(settings["socksVersion"]);`
	`176`	`+ this.SocksVersion = Convert.ToInt32(socksVersion);`
`178`	`177`	`}`
`179`	`178`
`180`		`- if (settings.ContainsKey("autodetect") && settings["autodetect"] != null)`
	`179`	`+ if (settings.TryGetValue("autodetect", out object? autodetect) && autodetect != null)`
`181`	`180`	`{`
`182`		`- this.IsAutoDetect = (bool)settings["autodetect"];`
	`181`	`+ this.IsAutoDetect = Convert.ToBoolean(autodetect);`
`183`	`182`	`}`
`184`	`183`	`}`
`185`	`184`
`@@ -189,10 +188,7 @@ public Proxy(Dictionary<string, object> settings)`
`189`	`188`	`[JsonIgnore]`
`190`	`189`	`public ProxyKind Kind`
`191`	`190`	`{`
`192`		`- get`
`193`		`- {`
`194`		`- return this.proxyKind;`
`195`		`- }`
	`191`	`+ get => this.proxyKind;`
`196`	`192`
`197`	`193`	`set`
`198`	`194`	`{`
`@@ -224,10 +220,7 @@ public string SerializableProxyKind`
`224`	`220`	`[JsonIgnore]`
`225`	`221`	`public bool IsAutoDetect`
`226`	`222`	`{`
`227`		`- get`
`228`		`- {`
`229`		`- return this.isAutoDetect;`
`230`		`- }`
	`223`	`+ get => this.isAutoDetect;`
`231`	`224`
`232`	`225`	`set`
`233`	`226`	`{`
`@@ -247,12 +240,9 @@ public bool IsAutoDetect`
`247`	`240`	`/// </summary>`
`248`	`241`	`[JsonPropertyName("ftpProxy")]`
`249`	`242`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`250`		`- public string FtpProxy`
	`243`	`+ public string? FtpProxy`
`251`	`244`	`{`
`252`		`- get`
`253`		`- {`
`254`		`- return this.ftpProxyLocation;`
`255`		`- }`
	`245`	`+ get => this.ftpProxyLocation;`
`256`	`246`
`257`	`247`	`set`
`258`	`248`	`{`
`@@ -267,12 +257,9 @@ public string FtpProxy`
`267`	`257`	`/// </summary>`
`268`	`258`	`[JsonPropertyName("httpProxy")]`
`269`	`259`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`270`		`- public string HttpProxy`
	`260`	`+ public string? HttpProxy`
`271`	`261`	`{`
`272`		`- get`
`273`		`- {`
`274`		`- return this.httpProxyLocation;`
`275`		`- }`
	`262`	`+ get => this.httpProxyLocation;`
`276`	`263`
`277`	`264`	`set`
`278`	`265`	`{`
`@@ -287,7 +274,7 @@ public string HttpProxy`
`287`	`274`	`/// </summary>`
`288`	`275`	`[JsonPropertyName("noProxy")]`
`289`	`276`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`290`		`- public ReadOnlyCollection<string> BypassProxyAddresses`
	`277`	`+ public ReadOnlyCollection<string>? BypassProxyAddresses`
`291`	`278`	`{`
`292`	`279`	`get`
`293`	`280`	`{`
`@@ -305,12 +292,9 @@ public ReadOnlyCollection<string> BypassProxyAddresses`
`305`	`292`	`/// </summary>`
`306`	`293`	`[JsonPropertyName("proxyAutoconfigUrl")]`
`307`	`294`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`308`		`- public string ProxyAutoConfigUrl`
	`295`	`+ public string? ProxyAutoConfigUrl`
`309`	`296`	`{`
`310`		`- get`
`311`		`- {`
`312`		`- return this.proxyAutoConfigUrl;`
`313`		`- }`
	`297`	`+ get => this.proxyAutoConfigUrl;`
`314`	`298`
`315`	`299`	`set`
`316`	`300`	`{`
`@@ -325,12 +309,9 @@ public string ProxyAutoConfigUrl`
`325`	`309`	`/// </summary>`
`326`	`310`	`[JsonPropertyName("sslProxy")]`
`327`	`311`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`328`		`- public string SslProxy`
	`312`	`+ public string? SslProxy`
`329`	`313`	`{`
`330`		`- get`
`331`		`- {`
`332`		`- return this.sslProxyLocation;`
`333`		`- }`
	`314`	`+ get => this.sslProxyLocation;`
`334`	`315`
`335`	`316`	`set`
`336`	`317`	`{`
`@@ -345,12 +326,9 @@ public string SslProxy`
`345`	`326`	`/// </summary>`
`346`	`327`	`[JsonPropertyName("socksProxy")]`
`347`	`328`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`348`		`- public string SocksProxy`
	`329`	`+ public string? SocksProxy`
`349`	`330`	`{`
`350`		`- get`
`351`		`- {`
`352`		`- return this.socksProxyLocation;`
`353`		`- }`
	`331`	`+ get => this.socksProxyLocation;`
`354`	`332`
`355`	`333`	`set`
`356`	`334`	`{`
`@@ -365,12 +343,9 @@ public string SocksProxy`
`365`	`343`	`/// </summary>`
`366`	`344`	`[JsonPropertyName("socksUsername")]`
`367`	`345`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`368`		`- public string SocksUserName`
	`346`	`+ public string? SocksUserName`
`369`	`347`	`{`
`370`		`- get`
`371`		`- {`
`372`		`- return this.socksUserName;`
`373`		`- }`
	`348`	`+ get => this.socksUserName;`
`374`	`349`
`375`	`350`	`set`
`376`	`351`	`{`
`@@ -388,10 +363,7 @@ public string SocksUserName`
`388`	`363`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`389`	`364`	`public int? SocksVersion`
`390`	`365`	`{`
`391`		`- get`
`392`		`- {`
`393`		`- return this.socksVersion;`
`394`		`- }`
	`366`	`+ get => this.socksVersion;`
`395`	`367`
`396`	`368`	`set`
`397`	`369`	`{`
`@@ -403,7 +375,7 @@ public int? SocksVersion`
`403`	`375`	`{`
`404`	`376`	`if (value.Value <= 0)`
`405`	`377`	`{`
`406`		`- throw new ArgumentException("SocksVersion must be a positive integer");`
	`378`	`+ throw new ArgumentOutOfRangeException(nameof(value), "SocksVersion must be a positive integer");`
`407`	`379`	`}`
`408`	`380`
`409`	`381`	`this.VerifyProxyTypeCompatilibily(ProxyKind.Manual);`
`@@ -418,12 +390,9 @@ public int? SocksVersion`
`418`	`390`	`/// </summary>`
`419`	`391`	`[JsonPropertyName("socksPassword")]`
`420`	`392`	`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]`
`421`		`- public string SocksPassword`
	`393`	`+ public string? SocksPassword`
`422`	`394`	`{`
`423`		`- get`
`424`		`- {`
`425`		`- return this.socksPassword;`
`426`		`- }`
	`395`	`+ get => this.socksPassword;`
`427`	`396`
`428`	`397`	`set`
`429`	`398`	`{`
`@@ -453,7 +422,7 @@ public void AddBypassAddress(string address)`
`453`	`422`	`/// <param name="addressesToAdd">An array of addresses to add.</param>`
`454`	`423`	`public void AddBypassAddresses(params string[] addressesToAdd)`
`455`	`424`	`{`
`456`		`- this.AddBypassAddresses(new List<string>(addressesToAdd));`
	`425`	`+ this.AddBypassAddresses((IEnumerable<string>)addressesToAdd);`
`457`	`426`	`}`
`458`	`427`
`459`	`428`	`/// <summary>`
`@@ -478,7 +447,7 @@ public void AddBypassAddresses(IEnumerable<string> addressesToAdd)`
`478`	`447`	`/// </summary>`
`479`	`448`	`/// <returns>A dictionary suitable for serializing to the W3C Specification`
`480`	`449`	`/// dialect of the wire protocol.</returns>`
`481`		`- internal Dictionary<string, object> ToCapability()`
	`450`	`+ internal Dictionary<string, object?>? ToCapability()`
`482`	`451`	`{`
`483`	`452`	`return this.AsDictionary(true);`
`484`	`453`	`}`
`@@ -489,17 +458,17 @@ internal Dictionary<string, object> ToCapability()`
`489`	`458`	`/// </summary>`
`490`	`459`	`/// <returns>A dictionary suitable for serializing to the OSS dialect of the`
`491`	`460`	`/// wire protocol.</returns>`
`492`		`- internal Dictionary<string, object> ToLegacyCapability()`
	`461`	`+ internal Dictionary<string, object?>? ToLegacyCapability()`
`493`	`462`	`{`
`494`	`463`	`return this.AsDictionary(false);`
`495`	`464`	`}`
`496`	`465`
`497`		`- private Dictionary<string, object> AsDictionary(bool isSpecCompliant)`
	`466`	`+ private Dictionary<string, object?>? AsDictionary(bool isSpecCompliant)`
`498`	`467`	`{`
`499`		`- Dictionary<string, object> serializedDictionary = null;`
	`468`	`+ Dictionary<string, object?>? serializedDictionary = null;`
`500`	`469`	`if (this.proxyKind != ProxyKind.Unspecified)`
`501`	`470`	`{`
`502`		`- serializedDictionary = new Dictionary<string, object>();`
	`471`	`+ serializedDictionary = new Dictionary<string, object?>();`
`503`	`472`	`if (this.proxyKind == ProxyKind.ProxyAutoConfigure)`
`504`	`473`	`{`
`505`	`474`	`serializedDictionary["proxyType"] = "pac";`
`@@ -556,17 +525,12 @@ private Dictionary<string, object> AsDictionary(bool isSpecCompliant)`
`556`	`525`	`return serializedDictionary;`
`557`	`526`	`}`
`558`	`527`
`559`		`- private object GetNoProxyAddressList(bool isSpecCompliant)`
	`528`	`+ private object? GetNoProxyAddressList(bool isSpecCompliant)`
`560`	`529`	`{`
`561`		`- object addresses = null;`
	`530`	`+ object? addresses = null;`
`562`	`531`	`if (isSpecCompliant)`
`563`	`532`	`{`
`564`		`- List<object> addressList = new List<object>();`
`565`		`- foreach (string address in this.noProxyAddresses)`
`566`		`- {`
`567`		`- addressList.Add(address);`
`568`		`- }`
`569`		`-`
	`533`	`+ List<object> addressList = [.. this.noProxyAddresses];`
`570`	`534`	`addresses = addressList;`
`571`	`535`	`}`
`572`	`536`	`else`