use extension members for string.Join etc

mus65 · mus65 · commit 7bc282852a71 · 2025-09-26T20:11:52.000+02:00
diff --git a/src/Renci.SshNet/Abstractions/StringExtensions.cs b/src/Renci.SshNet/Abstractions/StringExtensions.cs
@@ -0,0 +1,35 @@
+﻿#nullable enable
+#if NETSTANDARD2_0 || NETFRAMEWORK
+using System.Collections.Generic;
+#endif
+
+namespace System
+{
+    internal static class StringExtensions
+    {
+        extension(string text)
+        {
+#if NETSTANDARD2_0 || NETFRAMEWORK
+            public static string Join(char separator, params string?[] value)
+            {
+                return string.Join(separator.ToString(), value);
+            }
+
+            public static string Join(char separator, IEnumerable<string?> value)
+            {
+                return string.Join(separator.ToString(), value);
+            }
+
+            public static string Join(char separator, string?[] value, int startIndex, int count)
+            {
+                return string.Join(separator.ToString(), value, startIndex, count);
+            }
+
+            public int IndexOf(char value, StringComparison comparisonType)
+            {
+                return text.IndexOf(value.ToString(), comparisonType);
+            }
+#endif
+        }
+    }
+}
diff --git a/src/Renci.SshNet/ClientAuthentication.cs b/src/Renci.SshNet/ClientAuthentication.cs
@@ -105,12 +105,7 @@ private bool TryAuthenticate(ISession session,
             {
                 authenticationException = new SshAuthenticationException(string.Format(CultureInfo.InvariantCulture,
                                                                                        "No suitable authentication method found to complete authentication ({0}).",
-#if NET
-                                                                                       string.Join(',', allowedAuthenticationMethods)))
-#else
-                                                                                       string.Join(",", allowedAuthenticationMethods)))
-#endif
-                ;
+                                                                                       string.Join(',', allowedAuthenticationMethods)));
                 return false;
             }
 
diff --git a/src/Renci.SshNet/Common/Extensions.cs b/src/Renci.SshNet/Common/Extensions.cs
@@ -1,5 +1,7 @@
 ﻿using System;
+#if !NET
 using System.Collections.Generic;
+#endif
 using System.Globalization;
 #if !NET
 using System.IO;
@@ -339,13 +341,6 @@ internal static bool IsConnected(this Socket socket)
             return socket.Connected;
         }
 
-        internal static string Join(this IEnumerable<string> values, string separator)
-        {
-            // Used to avoid analyzers asking to "use an overload with a char parameter"
-            // which is not available on all targets.
-            return string.Join(separator, values);
-        }
-
 #if !NET
         internal static bool TryAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue value)
         {
diff --git a/src/Renci.SshNet/Common/SshData.cs b/src/Renci.SshNet/Common/SshData.cs
@@ -386,11 +386,7 @@ protected void Write(BigInteger data)
         /// <param name="data">name-list data to write.</param>
         protected void Write(string[] data)
         {
-#if NET
             Write(string.Join(',', data), Ascii);
-#else
-            Write(string.Join(",", data), Ascii);
-#endif
         }
 
         /// <summary>
diff --git a/src/Renci.SshNet/Messages/Authentication/FailureMessage.cs b/src/Renci.SshNet/Messages/Authentication/FailureMessage.cs
@@ -55,11 +55,7 @@ protected override void LoadData()
             PartialSuccess = ReadBoolean();
             if (PartialSuccess)
             {
-#if NET
                 Message = string.Join(',', AllowedAuthentications);
-#else
-                Message = string.Join(",", AllowedAuthentications);
-#endif
             }
         }
 
diff --git a/src/Renci.SshNet/Security/KeyExchange.cs b/src/Renci.SshNet/Security/KeyExchange.cs
@@ -91,17 +91,17 @@ from a in message.ServerHostKeyAlgorithms
             {
                 _logger.LogTrace("[{SessionId}] Host key algorithm: we offer {WeOffer}",
                     Session.SessionIdHex,
-                    session.ConnectionInfo.HostKeyAlgorithms.Keys.Join(","));
+                    string.Join(',', session.ConnectionInfo.HostKeyAlgorithms.Keys));
 
                 _logger.LogTrace("[{SessionId}] Host key algorithm: they offer {TheyOffer}",
                     Session.SessionIdHex,
-                    message.ServerHostKeyAlgorithms.Join(","));
+                    string.Join(',', message.ServerHostKeyAlgorithms));
             }
 
             if (hostKeyAlgorithmName is null)
             {
                 throw new SshConnectionException(
-                    $"No matching host key algorithm (server offers {message.ServerHostKeyAlgorithms.Join(",")})",
+                    $"No matching host key algorithm (server offers {string.Join(',', message.ServerHostKeyAlgorithms)})",
                     DisconnectReason.KeyExchangeFailed);
             }
 
@@ -118,17 +118,17 @@ from a in message.EncryptionAlgorithmsClientToServer
             {
                 _logger.LogTrace("[{SessionId}] Encryption client to server: we offer {WeOffer}",
                     Session.SessionIdHex,
-                    session.ConnectionInfo.Encryptions.Keys.Join(","));
+                    string.Join(',', session.ConnectionInfo.Encryptions.Keys));
 
                 _logger.LogTrace("[{SessionId}] Encryption client to server: they offer {TheyOffer}",
                     Session.SessionIdHex,
-                    message.EncryptionAlgorithmsClientToServer.Join(","));
+                    string.Join(',', message.EncryptionAlgorithmsClientToServer));
             }
 
             if (clientEncryptionAlgorithmName is null)
             {
                 throw new SshConnectionException(
-                    $"No matching client encryption algorithm (server offers {message.EncryptionAlgorithmsClientToServer.Join(",")})",
+                    $"No matching client encryption algorithm (server offers {string.Join(',', message.EncryptionAlgorithmsClientToServer)})",
                     DisconnectReason.KeyExchangeFailed);
             }
 
@@ -145,17 +145,17 @@ from a in message.EncryptionAlgorithmsServerToClient
             {
                 _logger.LogTrace("[{SessionId}] Encryption server to client: we offer {WeOffer}",
                     Session.SessionIdHex,
-                    session.ConnectionInfo.Encryptions.Keys.Join(","));
+                    string.Join(',', session.ConnectionInfo.Encryptions.Keys));
 
                 _logger.LogTrace("[{SessionId}] Encryption server to client: they offer {TheyOffer}",
                     Session.SessionIdHex,
-                    message.EncryptionAlgorithmsServerToClient.Join(","));
+                    string.Join(',', message.EncryptionAlgorithmsServerToClient));
             }
 
             if (serverDecryptionAlgorithmName is null)
             {
                 throw new SshConnectionException(
-                    $"No matching server encryption algorithm (server offers {message.EncryptionAlgorithmsServerToClient.Join(",")})",
+                    $"No matching server encryption algorithm (server offers {string.Join(',', message.EncryptionAlgorithmsServerToClient)})",
                     DisconnectReason.KeyExchangeFailed);
             }
 
@@ -174,17 +174,17 @@ from a in message.MacAlgorithmsClientToServer
                 {
                     _logger.LogTrace("[{SessionId}] MAC client to server: we offer {WeOffer}",
                         Session.SessionIdHex,
-                        session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));
+                        string.Join(',', session.ConnectionInfo.HmacAlgorithms.Keys));
 
                     _logger.LogTrace("[{SessionId}] MAC client to server: they offer {TheyOffer}",
                         Session.SessionIdHex,
-                        message.MacAlgorithmsClientToServer.Join(","));
+                        string.Join(',', message.MacAlgorithmsClientToServer));
                 }
 
                 if (clientHmacAlgorithmName is null)
                 {
                     throw new SshConnectionException(
-                        $"No matching client MAC algorithm (server offers {message.MacAlgorithmsClientToServer.Join(",")})",
+                        $"No matching client MAC algorithm (server offers {string.Join(',', message.MacAlgorithmsClientToServer)})",
                         DisconnectReason.KeyExchangeFailed);
                 }
 
@@ -204,17 +204,17 @@ from a in message.MacAlgorithmsServerToClient
                 {
                     _logger.LogTrace("[{SessionId}] MAC server to client: we offer {WeOffer}",
                         Session.SessionIdHex,
-                        session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));
+                        string.Join(',', session.ConnectionInfo.HmacAlgorithms.Keys));
 
                     _logger.LogTrace("[{SessionId}] MAC server to client: they offer {TheyOffer}",
                         Session.SessionIdHex,
-                        message.MacAlgorithmsServerToClient.Join(","));
+                        string.Join(',', message.MacAlgorithmsServerToClient));
                 }
 
                 if (serverHmacAlgorithmName is null)
                 {
                     throw new SshConnectionException(
-                        $"No matching server MAC algorithm (server offers {message.MacAlgorithmsServerToClient.Join(",")})",
+                        $"No matching server MAC algorithm (server offers {string.Join(',', message.MacAlgorithmsServerToClient)})",
                         DisconnectReason.KeyExchangeFailed);
                 }
 
@@ -232,17 +232,17 @@ from a in message.CompressionAlgorithmsClientToServer
             {
                 _logger.LogTrace("[{SessionId}] Compression client to server: we offer {WeOffer}",
                     Session.SessionIdHex,
-                    session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));
+                    string.Join(',', session.ConnectionInfo.CompressionAlgorithms.Keys));
 
                 _logger.LogTrace("[{SessionId}] Compression client to server: they offer {TheyOffer}",
                     Session.SessionIdHex,
-                    message.CompressionAlgorithmsClientToServer.Join(","));
+                    string.Join(',', message.CompressionAlgorithmsClientToServer));
             }
 
             if (compressionAlgorithmName is null)
             {
                 throw new SshConnectionException(
-                    $"No matching client compression algorithm (server offers {message.CompressionAlgorithmsClientToServer.Join(",")})",
+                    $"No matching client compression algorithm (server offers {string.Join(',', message.CompressionAlgorithmsClientToServer)})",
                     DisconnectReason.KeyExchangeFailed);
             }
 
@@ -259,17 +259,17 @@ from a in message.CompressionAlgorithmsServerToClient
             {
                 _logger.LogTrace("[{SessionId}] Compression server to client: we offer {WeOffer}",
                     Session.SessionIdHex,
-                    session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));
+                    string.Join(',', session.ConnectionInfo.CompressionAlgorithms.Keys));
 
                 _logger.LogTrace("[{SessionId}] Compression server to client: they offer {TheyOffer}",
                     Session.SessionIdHex,
-                    message.CompressionAlgorithmsServerToClient.Join(","));
+                    string.Join(',', message.CompressionAlgorithmsServerToClient));
             }
 
             if (decompressionAlgorithmName is null)
             {
                 throw new SshConnectionException(
-                    $"No matching server compression algorithm (server offers {message.CompressionAlgorithmsServerToClient.Join(",")})",
+                    $"No matching server compression algorithm (server offers {string.Join(',', message.CompressionAlgorithmsServerToClient)})",
                     DisconnectReason.KeyExchangeFailed);
             }
 
diff --git a/src/Renci.SshNet/ServiceFactory.cs b/src/Renci.SshNet/ServiceFactory.cs
@@ -98,7 +98,7 @@ from s in serverAlgorithms
 
             if (keyExchangeAlgorithmFactory is null)
             {
-                throw new SshConnectionException($"No matching key exchange algorithm (server offers {serverAlgorithms.Join(",")})", DisconnectReason.KeyExchangeFailed);
+                throw new SshConnectionException($"No matching key exchange algorithm (server offers {string.Join(',', serverAlgorithms)})", DisconnectReason.KeyExchangeFailed);
             }
 
             return keyExchangeAlgorithmFactory();
diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -137,22 +137,14 @@ public string GetCanonicalPath(string path)
             if (fullPath.EndsWith("/.", StringComparison.OrdinalIgnoreCase) ||
                 fullPath.EndsWith("/..", StringComparison.OrdinalIgnoreCase) ||
                 fullPath.Equals("/", StringComparison.OrdinalIgnoreCase) ||
-#if NET
                 fullPath.IndexOf('/', StringComparison.OrdinalIgnoreCase) < 0)
-#else
-                fullPath.IndexOf('/') < 0)
-#endif
             {
                 return fullPath;
             }
 
             var pathParts = fullPath.Split('/');
 
-#if NET
             var partialFullPath = string.Join('/', pathParts, 0, pathParts.Length - 1);
-#else
-            var partialFullPath = string.Join("/", pathParts, 0, pathParts.Length - 1);
-#endif
 
             if (string.IsNullOrEmpty(partialFullPath))
             {

Original file line number	Diff line number	Diff line change
`@@ -105,12 +105,7 @@ private bool TryAuthenticate(ISession session,`
`105`	`105`	`{`
`106`	`106`	`authenticationException = new SshAuthenticationException(string.Format(CultureInfo.InvariantCulture,`
`107`	`107`	`"No suitable authentication method found to complete authentication ({0}).",`
`108`		`-#if NET`
`109`		`- string.Join(',', allowedAuthenticationMethods)))`
`110`		`-#else`
`111`		`- string.Join(",", allowedAuthenticationMethods)))`
`112`		`-#endif`
`113`		`- ;`
	`108`	`+ string.Join(',', allowedAuthenticationMethods)));`
`114`	`109`	`return false;`
`115`	`110`	`}`
`116`	`111`
Original file line number	Diff line number	Diff line change
`@@ -386,11 +386,7 @@ protected void Write(BigInteger data)`
`386`	`386`	`/// <param name="data">name-list data to write.</param>`
`387`	`387`	`protected void Write(string[] data)`
`388`	`388`	`{`
`389`		`-#if NET`
`390`	`389`	`Write(string.Join(',', data), Ascii);`
`391`		`-#else`
`392`		`- Write(string.Join(",", data), Ascii);`
`393`		`-#endif`
`394`	`390`	`}`
`395`	`391`
`396`	`392`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -55,11 +55,7 @@ protected override void LoadData()`
`55`	`55`	`PartialSuccess = ReadBoolean();`
`56`	`56`	`if (PartialSuccess)`
`57`	`57`	`{`
`58`		`-#if NET`
`59`	`58`	`Message = string.Join(',', AllowedAuthentications);`
`60`		`-#else`
`61`		`- Message = string.Join(",", AllowedAuthentications);`
`62`		`-#endif`
`63`	`59`	`}`
`64`	`60`	`}`
`65`	`61`
Original file line number	Diff line number	Diff line change
`@@ -91,17 +91,17 @@ from a in message.ServerHostKeyAlgorithms`
`91`	`91`	`{`
`92`	`92`	`_logger.LogTrace("[{SessionId}] Host key algorithm: we offer {WeOffer}",`
`93`	`93`	`Session.SessionIdHex,`
`94`		`- session.ConnectionInfo.HostKeyAlgorithms.Keys.Join(","));`
	`94`	`+ string.Join(',', session.ConnectionInfo.HostKeyAlgorithms.Keys));`
`95`	`95`
`96`	`96`	`_logger.LogTrace("[{SessionId}] Host key algorithm: they offer {TheyOffer}",`
`97`	`97`	`Session.SessionIdHex,`
`98`		`- message.ServerHostKeyAlgorithms.Join(","));`
	`98`	`+ string.Join(',', message.ServerHostKeyAlgorithms));`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`if (hostKeyAlgorithmName is null)`
`102`	`102`	`{`
`103`	`103`	`throw new SshConnectionException(`
`104`		`- $"No matching host key algorithm (server offers {message.ServerHostKeyAlgorithms.Join(",")})",`
	`104`	`+ $"No matching host key algorithm (server offers {string.Join(',', message.ServerHostKeyAlgorithms)})",`
`105`	`105`	`DisconnectReason.KeyExchangeFailed);`
`106`	`106`	`}`
`107`	`107`
`@@ -118,17 +118,17 @@ from a in message.EncryptionAlgorithmsClientToServer`
`118`	`118`	`{`
`119`	`119`	`_logger.LogTrace("[{SessionId}] Encryption client to server: we offer {WeOffer}",`
`120`	`120`	`Session.SessionIdHex,`
`121`		`- session.ConnectionInfo.Encryptions.Keys.Join(","));`
	`121`	`+ string.Join(',', session.ConnectionInfo.Encryptions.Keys));`
`122`	`122`
`123`	`123`	`_logger.LogTrace("[{SessionId}] Encryption client to server: they offer {TheyOffer}",`
`124`	`124`	`Session.SessionIdHex,`
`125`		`- message.EncryptionAlgorithmsClientToServer.Join(","));`
	`125`	`+ string.Join(',', message.EncryptionAlgorithmsClientToServer));`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`if (clientEncryptionAlgorithmName is null)`
`129`	`129`	`{`
`130`	`130`	`throw new SshConnectionException(`
`131`		`- $"No matching client encryption algorithm (server offers {message.EncryptionAlgorithmsClientToServer.Join(",")})",`
	`131`	`+ $"No matching client encryption algorithm (server offers {string.Join(',', message.EncryptionAlgorithmsClientToServer)})",`
`132`	`132`	`DisconnectReason.KeyExchangeFailed);`
`133`	`133`	`}`
`134`	`134`
`@@ -145,17 +145,17 @@ from a in message.EncryptionAlgorithmsServerToClient`
`145`	`145`	`{`
`146`	`146`	`_logger.LogTrace("[{SessionId}] Encryption server to client: we offer {WeOffer}",`
`147`	`147`	`Session.SessionIdHex,`
`148`		`- session.ConnectionInfo.Encryptions.Keys.Join(","));`
	`148`	`+ string.Join(',', session.ConnectionInfo.Encryptions.Keys));`
`149`	`149`
`150`	`150`	`_logger.LogTrace("[{SessionId}] Encryption server to client: they offer {TheyOffer}",`
`151`	`151`	`Session.SessionIdHex,`
`152`		`- message.EncryptionAlgorithmsServerToClient.Join(","));`
	`152`	`+ string.Join(',', message.EncryptionAlgorithmsServerToClient));`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`if (serverDecryptionAlgorithmName is null)`
`156`	`156`	`{`
`157`	`157`	`throw new SshConnectionException(`
`158`		`- $"No matching server encryption algorithm (server offers {message.EncryptionAlgorithmsServerToClient.Join(",")})",`
	`158`	`+ $"No matching server encryption algorithm (server offers {string.Join(',', message.EncryptionAlgorithmsServerToClient)})",`
`159`	`159`	`DisconnectReason.KeyExchangeFailed);`
`160`	`160`	`}`
`161`	`161`
`@@ -174,17 +174,17 @@ from a in message.MacAlgorithmsClientToServer`
`174`	`174`	`{`
`175`	`175`	`_logger.LogTrace("[{SessionId}] MAC client to server: we offer {WeOffer}",`
`176`	`176`	`Session.SessionIdHex,`
`177`		`- session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));`
	`177`	`+ string.Join(',', session.ConnectionInfo.HmacAlgorithms.Keys));`
`178`	`178`
`179`	`179`	`_logger.LogTrace("[{SessionId}] MAC client to server: they offer {TheyOffer}",`
`180`	`180`	`Session.SessionIdHex,`
`181`		`- message.MacAlgorithmsClientToServer.Join(","));`
	`181`	`+ string.Join(',', message.MacAlgorithmsClientToServer));`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`if (clientHmacAlgorithmName is null)`
`185`	`185`	`{`
`186`	`186`	`throw new SshConnectionException(`
`187`		`- $"No matching client MAC algorithm (server offers {message.MacAlgorithmsClientToServer.Join(",")})",`
	`187`	`+ $"No matching client MAC algorithm (server offers {string.Join(',', message.MacAlgorithmsClientToServer)})",`
`188`	`188`	`DisconnectReason.KeyExchangeFailed);`
`189`	`189`	`}`
`190`	`190`
`@@ -204,17 +204,17 @@ from a in message.MacAlgorithmsServerToClient`
`204`	`204`	`{`
`205`	`205`	`_logger.LogTrace("[{SessionId}] MAC server to client: we offer {WeOffer}",`
`206`	`206`	`Session.SessionIdHex,`
`207`		`- session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));`
	`207`	`+ string.Join(',', session.ConnectionInfo.HmacAlgorithms.Keys));`
`208`	`208`
`209`	`209`	`_logger.LogTrace("[{SessionId}] MAC server to client: they offer {TheyOffer}",`
`210`	`210`	`Session.SessionIdHex,`
`211`		`- message.MacAlgorithmsServerToClient.Join(","));`
	`211`	`+ string.Join(',', message.MacAlgorithmsServerToClient));`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`if (serverHmacAlgorithmName is null)`
`215`	`215`	`{`
`216`	`216`	`throw new SshConnectionException(`
`217`		`- $"No matching server MAC algorithm (server offers {message.MacAlgorithmsServerToClient.Join(",")})",`
	`217`	`+ $"No matching server MAC algorithm (server offers {string.Join(',', message.MacAlgorithmsServerToClient)})",`
`218`	`218`	`DisconnectReason.KeyExchangeFailed);`
`219`	`219`	`}`
`220`	`220`
`@@ -232,17 +232,17 @@ from a in message.CompressionAlgorithmsClientToServer`
`232`	`232`	`{`
`233`	`233`	`_logger.LogTrace("[{SessionId}] Compression client to server: we offer {WeOffer}",`
`234`	`234`	`Session.SessionIdHex,`
`235`		`- session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));`
	`235`	`+ string.Join(',', session.ConnectionInfo.CompressionAlgorithms.Keys));`
`236`	`236`
`237`	`237`	`_logger.LogTrace("[{SessionId}] Compression client to server: they offer {TheyOffer}",`
`238`	`238`	`Session.SessionIdHex,`
`239`		`- message.CompressionAlgorithmsClientToServer.Join(","));`
	`239`	`+ string.Join(',', message.CompressionAlgorithmsClientToServer));`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`if (compressionAlgorithmName is null)`
`243`	`243`	`{`
`244`	`244`	`throw new SshConnectionException(`
`245`		`- $"No matching client compression algorithm (server offers {message.CompressionAlgorithmsClientToServer.Join(",")})",`
	`245`	`+ $"No matching client compression algorithm (server offers {string.Join(',', message.CompressionAlgorithmsClientToServer)})",`
`246`	`246`	`DisconnectReason.KeyExchangeFailed);`
`247`	`247`	`}`
`248`	`248`
`@@ -259,17 +259,17 @@ from a in message.CompressionAlgorithmsServerToClient`
`259`	`259`	`{`
`260`	`260`	`_logger.LogTrace("[{SessionId}] Compression server to client: we offer {WeOffer}",`
`261`	`261`	`Session.SessionIdHex,`
`262`		`- session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));`
	`262`	`+ string.Join(',', session.ConnectionInfo.CompressionAlgorithms.Keys));`
`263`	`263`
`264`	`264`	`_logger.LogTrace("[{SessionId}] Compression server to client: they offer {TheyOffer}",`
`265`	`265`	`Session.SessionIdHex,`
`266`		`- message.CompressionAlgorithmsServerToClient.Join(","));`
	`266`	`+ string.Join(',', message.CompressionAlgorithmsServerToClient));`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`if (decompressionAlgorithmName is null)`
`270`	`270`	`{`
`271`	`271`	`throw new SshConnectionException(`
`272`		`- $"No matching server compression algorithm (server offers {message.CompressionAlgorithmsServerToClient.Join(",")})",`
	`272`	`+ $"No matching server compression algorithm (server offers {string.Join(',', message.CompressionAlgorithmsServerToClient)})",`
`273`	`273`	`DisconnectReason.KeyExchangeFailed);`
`274`	`274`	`}`
`275`	`275`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ from s in serverAlgorithms`
`98`	`98`
`99`	`99`	`if (keyExchangeAlgorithmFactory is null)`
`100`	`100`	`{`
`101`		`- throw new SshConnectionException($"No matching key exchange algorithm (server offers {serverAlgorithms.Join(",")})", DisconnectReason.KeyExchangeFailed);`
	`101`	`+ throw new SshConnectionException($"No matching key exchange algorithm (server offers {string.Join(',', serverAlgorithms)})", DisconnectReason.KeyExchangeFailed);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`return keyExchangeAlgorithmFactory();`