Reduce string allocations in sys helpers (#1644)

paulomorgado · web-flow · commit 8c8f0f5353cd · 2026-05-29T16:23:23.000+01:00
Apply string interpolation and span-based trimming updates under src/SIPSorcery/sys.
Keep the KeyValuePair deconstruction helper because current transaction code still depends on it.
diff --git a/src/SIPSorcery/sys/Crypto/Crypto.cs b/src/SIPSorcery/sys/Crypto/Crypto.cs
@@ -293,7 +293,7 @@ private static FileStream GetFileStream(string filepath)
             if (!File.Exists(filepath))
             {
                 logger.LogError("Cannot open a non-existent file for a hash operation, {FilePath}.",  filepath);
-                throw new IOException("Cannot open a non-existent file for a hash operation, " + filepath + ".");
+                throw new IOException($"Cannot open a non-existent file for a hash operation, {filepath}.");
             }
 
             // Open the file.
@@ -303,7 +303,7 @@ private static FileStream GetFileStream(string filepath)
             {
                 inputStream.Close();
                 logger.LogError("Cannot perform a hash operation on an empty file, {FilePath}.", filepath);
-                throw new IOException("Cannot perform a hash operation on an empty file, " + filepath + ".");
+                throw new IOException($"Cannot perform a hash operation on an empty file, {filepath}.");
             }
 
             return inputStream;
diff --git a/src/SIPSorcery/sys/Crypto/PasswordHash.cs b/src/SIPSorcery/sys/Crypto/PasswordHash.cs
@@ -42,15 +42,15 @@ public static string GenerateSalt(int? explicitIterations = null)
         {
             if (explicitIterations.HasValue && explicitIterations.Value < RFC289_MINIMUM_ITERATIONS)
             {
-                throw new ArgumentException("Cannot be less than " + RFC289_MINIMUM_ITERATIONS, "explicitIterations");
+                throw new ArgumentException($"Cannot be less than {RFC289_MINIMUM_ITERATIONS}", "explicitIterations");
             }
 
             byte[] salt = new byte[SALT_SIZE];
             _randomProvider.GetBytes(salt);
 
             var iterations = (explicitIterations ?? RFC289_MINIMUM_ITERATIONS).ToString("X");
 
-            return iterations + "." + Convert.ToBase64String(salt);
+            return $"{iterations}.{Convert.ToBase64String(salt)}";
         }
 
         /// <summary>
diff --git a/src/SIPSorcery/sys/Formatting/NumberFormatting.cs b/src/SIPSorcery/sys/Formatting/NumberFormatting.cs
@@ -25,22 +25,22 @@ public static string ToSIFormat(double number, int decimalPlaces)
             if (number > 1000000000000)
             {
                 double teraNumber = Math.Round((double)(number / (double)100000000000), decimalPlaces);
-                return teraNumber.ToString() + "T";
+                return $"{teraNumber}T";
             }
             if (number > 1000000000)
             {
                 double gigaNumber = Math.Round((double)(number / (double)100000000), decimalPlaces);
-                return gigaNumber.ToString() + "G";
+                return $"{gigaNumber}G";
             }
             else if (number > 1000000)
             {
                 double kiloNumber = Math.Round((double)(number / (double)1000000), decimalPlaces);
-                return kiloNumber.ToString() + "M";
+                return $"{kiloNumber}M";
             }
             else if (number > 1000)
             {
                 double kiloNumber = Math.Round((double)(number / (double)1000), decimalPlaces);
-                return kiloNumber.ToString() + "k";
+                return $"{kiloNumber}k";
             }
             else
             {
@@ -53,26 +53,26 @@ private static string ToSIByteFormat(double number, int decimalPlaces, string su
             if (number > 1099511627776)
             {
                 double teraNumber = Math.Round((double)(number / (double)1099511627776), decimalPlaces);
-                return teraNumber.ToString() + "T" + suffix;
+                return $"{teraNumber}T{suffix}";
             }
             if (number > 1073741824)
             {
                 double gigaNumber = Math.Round((double)(number / (double)1073741824), decimalPlaces);
-                return gigaNumber.ToString() + "G" + suffix;
+                return $"{gigaNumber}G{suffix}";
             }
             else if (number > 1048576)
             {
                 double kiloNumber = Math.Round((double)(number / (double)1048576), decimalPlaces);
-                return kiloNumber.ToString() + "M" + suffix;
+                return $"{kiloNumber}M{suffix}";
             }
             else if (number > 1024)
             {
                 double kiloNumber = Math.Round((double)(number / (double)1024), decimalPlaces);
-                return kiloNumber.ToString() + "K" + suffix;
+                return $"{kiloNumber}K{suffix}";
             }
             else
             {
-                return Math.Round((double)number, decimalPlaces).ToString() + suffix;
+                return $"{Math.Round((double)number, decimalPlaces)}{suffix}";
             }
         }
 
diff --git a/src/SIPSorcery/sys/Net/IPSocket.cs b/src/SIPSorcery/sys/Net/IPSocket.cs
@@ -44,8 +44,10 @@ public class IPSocket
         /// </summary>
         public static string GetSocketString(IPEndPoint endPoint)
         {
-            string format = (endPoint.Address.AddressFamily == AddressFamily.InterNetworkV6) ? "[{0}]:{1}" : "{0}:{1}";
-            return string.Format(format, endPoint.Address.ToString(), endPoint.Port.ToString(NumberFormatInfo.InvariantInfo));
+            var address = endPoint.Address.ToString();
+            var port = endPoint.Port.ToString(NumberFormatInfo.InvariantInfo);
+
+            return endPoint.Address.AddressFamily == AddressFamily.InterNetworkV6 ? $"[{address}]:{port}" : $"{address}:{port}";
         }
 
         /// <summary>
@@ -123,7 +125,7 @@ public static string ParseHostFromSocket(string socket)
         {
             string host = socket;
 
-            if (socket != null && socket.Trim().Length > 0 && socket.IndexOf(':') != -1)
+            if (!string.IsNullOrWhiteSpace(socket) && socket.IndexOf(':') != -1)
             {
                 host = socket.Substring(0, socket.LastIndexOf(':')).Trim();
             }
@@ -154,14 +156,14 @@ public static int ParsePortFromSocket(string socket)
                 }
                 // Look to see if this is IPv4 with a port (IPv6 will have another colon)
                 // If it's a host name there will also not be another ':'.
-                else if (socket.Substring(0, lastColonPos).LastIndexOf(':') != -1)
+                else if (socket.AsSpan(0, lastColonPos).LastIndexOf(':') != -1)
                 {
                     // This is an IPv6 address WITHOUT a port.
                     lastColonPos = -1;
                 }
             }
 
-            if (socket != null && socket.Trim().Length > 0 && lastColonPos != -1)
+            if (!string.IsNullOrWhiteSpace(socket) && lastColonPos != -1)
             {
                 port = Convert.ToInt32(socket.Substring(lastColonPos + 1).Trim());
             }
@@ -176,7 +178,7 @@ public static int ParsePortFromSocket(string socket)
         /// <returns>true/false</returns>
         public static bool IsIPAddress(string socket)
         {
-            if (socket == null || socket.Trim().Length == 0)
+            if (string.IsNullOrWhiteSpace(socket))
             {
                 return false;
             }
@@ -310,7 +312,7 @@ public static bool Parse(string endpointstring, out string host, out int port)
             }
             else
             {
-                throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
+                throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");
             }
 
             return rc;
@@ -327,7 +329,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)
                 (defaultport < IPEndPoint.MinPort
                 || defaultport > IPEndPoint.MaxPort))
             {
-                throw new ArgumentException(string.Format("Invalid default port '{0}'", defaultport));
+                throw new ArgumentException($"Invalid default port '{defaultport}'");
             }
 
             string[] values = endpointstring.Split(new char[] { ':' });
@@ -356,7 +358,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)
                     }
                     catch
                     {
-                        throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
+                        throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");
                     }
                 }
             }
@@ -377,7 +379,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)
             }
             else
             {
-                throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
+                throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");
             }
 
             if (port == -1)
@@ -396,7 +398,7 @@ private static int getPort(string p)
              || port < IPEndPoint.MinPort
              || port > IPEndPoint.MaxPort)
             {
-                throw new FormatException(string.Format("Invalid end point port '{0}'", p));
+                throw new FormatException($"Invalid end point port '{p}'");
             }
 
             return port;
@@ -410,13 +412,13 @@ private static IPAddress getIPfromHost(string p)
 
                 if (hosts == null || hosts.Length == 0)
                 {
-                    throw new ArgumentException(string.Format("Host not found: {0}", p));
+                    throw new ArgumentException($"Host not found: {p}");
                 }
                 return hosts[0];
             }
             catch
             {
-                throw new ArgumentException(string.Format("Host not found: {0}", p));
+                throw new ArgumentException($"Host not found: {p}");
             }
         }
 
diff --git a/src/SIPSorcery/sys/TypeExtensions.cs b/src/SIPSorcery/sys/TypeExtensions.cs
@@ -55,7 +55,7 @@ public static class TypeExtensions
         /// </summary>    
         public static bool IsNullOrBlank(this string s)
         {
-            if (s == null || s.Trim(WhiteSpaceChars).Length == 0)
+            if (s == null || s.AsSpan().Trim(WhiteSpaceChars).Length == 0)
             {
                 return true;
             }
@@ -65,7 +65,7 @@ public static bool IsNullOrBlank(this string s)
 
         public static bool NotNullOrBlank(this string s)
         {
-            if (s == null || s.Trim(WhiteSpaceChars).Length == 0)
+            if (s == null || s.AsSpan().Trim(WhiteSpaceChars).Length == 0)
             {
                 return false;
             }
@@ -206,13 +206,11 @@ public static byte[] ParseHexStr(string hexStr)
             return buffer.ToArray();
         }
 
-        //#if NET472 || NETSTANDARD2_0
         public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple, out T1 key, out T2 value)
         {
             key = tuple.Key;
             value = tuple.Value;
         }
-        //#endif
 
         public static bool IsPrivate(this IPAddress address)
         {

Original file line number	Diff line number	Diff line change
`@@ -293,7 +293,7 @@ private static FileStream GetFileStream(string filepath)`
`293`	`293`	`if (!File.Exists(filepath))`
`294`	`294`	`{`
`295`	`295`	`logger.LogError("Cannot open a non-existent file for a hash operation, {FilePath}.", filepath);`
`296`		`- throw new IOException("Cannot open a non-existent file for a hash operation, " + filepath + ".");`
	`296`	`+ throw new IOException($"Cannot open a non-existent file for a hash operation, {filepath}.");`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`// Open the file.`
`@@ -303,7 +303,7 @@ private static FileStream GetFileStream(string filepath)`
`303`	`303`	`{`
`304`	`304`	`inputStream.Close();`
`305`	`305`	`logger.LogError("Cannot perform a hash operation on an empty file, {FilePath}.", filepath);`
`306`		`- throw new IOException("Cannot perform a hash operation on an empty file, " + filepath + ".");`
	`306`	`+ throw new IOException($"Cannot perform a hash operation on an empty file, {filepath}.");`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`return inputStream;`
Original file line number	Diff line number	Diff line change
`@@ -42,15 +42,15 @@ public static string GenerateSalt(int? explicitIterations = null)`
`42`	`42`	`{`
`43`	`43`	`if (explicitIterations.HasValue && explicitIterations.Value < RFC289_MINIMUM_ITERATIONS)`
`44`	`44`	`{`
`45`		`- throw new ArgumentException("Cannot be less than " + RFC289_MINIMUM_ITERATIONS, "explicitIterations");`
	`45`	`+ throw new ArgumentException($"Cannot be less than {RFC289_MINIMUM_ITERATIONS}", "explicitIterations");`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`byte[] salt = new byte[SALT_SIZE];`
`49`	`49`	`_randomProvider.GetBytes(salt);`
`50`	`50`
`51`	`51`	`var iterations = (explicitIterations ?? RFC289_MINIMUM_ITERATIONS).ToString("X");`
`52`	`52`
`53`		`- return iterations + "." + Convert.ToBase64String(salt);`
	`53`	`+ return $"{iterations}.{Convert.ToBase64String(salt)}";`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -25,22 +25,22 @@ public static string ToSIFormat(double number, int decimalPlaces)`
`25`	`25`	`if (number > 1000000000000)`
`26`	`26`	`{`
`27`	`27`	`double teraNumber = Math.Round((double)(number / (double)100000000000), decimalPlaces);`
`28`		`- return teraNumber.ToString() + "T";`
	`28`	`+ return $"{teraNumber}T";`
`29`	`29`	`}`
`30`	`30`	`if (number > 1000000000)`
`31`	`31`	`{`
`32`	`32`	`double gigaNumber = Math.Round((double)(number / (double)100000000), decimalPlaces);`
`33`		`- return gigaNumber.ToString() + "G";`
	`33`	`+ return $"{gigaNumber}G";`
`34`	`34`	`}`
`35`	`35`	`else if (number > 1000000)`
`36`	`36`	`{`
`37`	`37`	`double kiloNumber = Math.Round((double)(number / (double)1000000), decimalPlaces);`
`38`		`- return kiloNumber.ToString() + "M";`
	`38`	`+ return $"{kiloNumber}M";`
`39`	`39`	`}`
`40`	`40`	`else if (number > 1000)`
`41`	`41`	`{`
`42`	`42`	`double kiloNumber = Math.Round((double)(number / (double)1000), decimalPlaces);`
`43`		`- return kiloNumber.ToString() + "k";`
	`43`	`+ return $"{kiloNumber}k";`
`44`	`44`	`}`
`45`	`45`	`else`
`46`	`46`	`{`
`@@ -53,26 +53,26 @@ private static string ToSIByteFormat(double number, int decimalPlaces, string su`
`53`	`53`	`if (number > 1099511627776)`
`54`	`54`	`{`
`55`	`55`	`double teraNumber = Math.Round((double)(number / (double)1099511627776), decimalPlaces);`
`56`		`- return teraNumber.ToString() + "T" + suffix;`
	`56`	`+ return $"{teraNumber}T{suffix}";`
`57`	`57`	`}`
`58`	`58`	`if (number > 1073741824)`
`59`	`59`	`{`
`60`	`60`	`double gigaNumber = Math.Round((double)(number / (double)1073741824), decimalPlaces);`
`61`		`- return gigaNumber.ToString() + "G" + suffix;`
	`61`	`+ return $"{gigaNumber}G{suffix}";`
`62`	`62`	`}`
`63`	`63`	`else if (number > 1048576)`
`64`	`64`	`{`
`65`	`65`	`double kiloNumber = Math.Round((double)(number / (double)1048576), decimalPlaces);`
`66`		`- return kiloNumber.ToString() + "M" + suffix;`
	`66`	`+ return $"{kiloNumber}M{suffix}";`
`67`	`67`	`}`
`68`	`68`	`else if (number > 1024)`
`69`	`69`	`{`
`70`	`70`	`double kiloNumber = Math.Round((double)(number / (double)1024), decimalPlaces);`
`71`		`- return kiloNumber.ToString() + "K" + suffix;`
	`71`	`+ return $"{kiloNumber}K{suffix}";`
`72`	`72`	`}`
`73`	`73`	`else`
`74`	`74`	`{`
`75`		`- return Math.Round((double)number, decimalPlaces).ToString() + suffix;`
	`75`	`+ return $"{Math.Round((double)number, decimalPlaces)}{suffix}";`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -44,8 +44,10 @@ public class IPSocket`
`44`	`44`	`/// </summary>`
`45`	`45`	`public static string GetSocketString(IPEndPoint endPoint)`
`46`	`46`	`{`
`47`		`- string format = (endPoint.Address.AddressFamily == AddressFamily.InterNetworkV6) ? "[{0}]:{1}" : "{0}:{1}";`
`48`		`- return string.Format(format, endPoint.Address.ToString(), endPoint.Port.ToString(NumberFormatInfo.InvariantInfo));`
	`47`	`+ var address = endPoint.Address.ToString();`
	`48`	`+ var port = endPoint.Port.ToString(NumberFormatInfo.InvariantInfo);`
	`49`	`+`
	`50`	`+ return endPoint.Address.AddressFamily == AddressFamily.InterNetworkV6 ? $"[{address}]:{port}" : $"{address}:{port}";`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`/// <summary>`
`@@ -123,7 +125,7 @@ public static string ParseHostFromSocket(string socket)`
`123`	`125`	`{`
`124`	`126`	`string host = socket;`
`125`	`127`
`126`		`- if (socket != null && socket.Trim().Length > 0 && socket.IndexOf(':') != -1)`
	`128`	`+ if (!string.IsNullOrWhiteSpace(socket) && socket.IndexOf(':') != -1)`
`127`	`129`	`{`
`128`	`130`	`host = socket.Substring(0, socket.LastIndexOf(':')).Trim();`
`129`	`131`	`}`
`@@ -154,14 +156,14 @@ public static int ParsePortFromSocket(string socket)`
`154`	`156`	`}`
`155`	`157`	`// Look to see if this is IPv4 with a port (IPv6 will have another colon)`
`156`	`158`	`// If it's a host name there will also not be another ':'.`
`157`		`- else if (socket.Substring(0, lastColonPos).LastIndexOf(':') != -1)`
	`159`	`+ else if (socket.AsSpan(0, lastColonPos).LastIndexOf(':') != -1)`
`158`	`160`	`{`
`159`	`161`	`// This is an IPv6 address WITHOUT a port.`
`160`	`162`	`lastColonPos = -1;`
`161`	`163`	`}`
`162`	`164`	`}`
`163`	`165`
`164`		`- if (socket != null && socket.Trim().Length > 0 && lastColonPos != -1)`
	`166`	`+ if (!string.IsNullOrWhiteSpace(socket) && lastColonPos != -1)`
`165`	`167`	`{`
`166`	`168`	`port = Convert.ToInt32(socket.Substring(lastColonPos + 1).Trim());`
`167`	`169`	`}`
`@@ -176,7 +178,7 @@ public static int ParsePortFromSocket(string socket)`
`176`	`178`	`/// <returns>true/false</returns>`
`177`	`179`	`public static bool IsIPAddress(string socket)`
`178`	`180`	`{`
`179`		`- if (socket == null \|\| socket.Trim().Length == 0)`
	`181`	`+ if (string.IsNullOrWhiteSpace(socket))`
`180`	`182`	`{`
`181`	`183`	`return false;`
`182`	`184`	`}`
`@@ -310,7 +312,7 @@ public static bool Parse(string endpointstring, out string host, out int port)`
`310`	`312`	`}`
`311`	`313`	`else`
`312`	`314`	`{`
`313`		`- throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));`
	`315`	`+ throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");`
`314`	`316`	`}`
`315`	`317`
`316`	`318`	`return rc;`
`@@ -327,7 +329,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)`
`327`	`329`	`(defaultport < IPEndPoint.MinPort`
`328`	`330`	`\|\| defaultport > IPEndPoint.MaxPort))`
`329`	`331`	`{`
`330`		`- throw new ArgumentException(string.Format("Invalid default port '{0}'", defaultport));`
	`332`	`+ throw new ArgumentException($"Invalid default port '{defaultport}'");`
`331`	`333`	`}`
`332`	`334`
`333`	`335`	`string[] values = endpointstring.Split(new char[] { ':' });`
`@@ -356,7 +358,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)`
`356`	`358`	`}`
`357`	`359`	`catch`
`358`	`360`	`{`
`359`		`- throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));`
	`361`	`+ throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");`
`360`	`362`	`}`
`361`	`363`	`}`
`362`	`364`	`}`
`@@ -377,7 +379,7 @@ public static IPEndPoint Parse(string endpointstring, int defaultport = -1)`
`377`	`379`	`}`
`378`	`380`	`else`
`379`	`381`	`{`
`380`		`- throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));`
	`382`	`+ throw new FormatException($"Invalid endpoint ipaddress '{endpointstring}'");`
`381`	`383`	`}`
`382`	`384`
`383`	`385`	`if (port == -1)`
`@@ -396,7 +398,7 @@ private static int getPort(string p)`
`396`	`398`	`\|\| port < IPEndPoint.MinPort`
`397`	`399`	`\|\| port > IPEndPoint.MaxPort)`
`398`	`400`	`{`
`399`		`- throw new FormatException(string.Format("Invalid end point port '{0}'", p));`
	`401`	`+ throw new FormatException($"Invalid end point port '{p}'");`
`400`	`402`	`}`
`401`	`403`
`402`	`404`	`return port;`
`@@ -410,13 +412,13 @@ private static IPAddress getIPfromHost(string p)`
`410`	`412`
`411`	`413`	`if (hosts == null \|\| hosts.Length == 0)`
`412`	`414`	`{`
`413`		`- throw new ArgumentException(string.Format("Host not found: {0}", p));`
	`415`	`+ throw new ArgumentException($"Host not found: {p}");`
`414`	`416`	`}`
`415`	`417`	`return hosts[0];`
`416`	`418`	`}`
`417`	`419`	`catch`
`418`	`420`	`{`
`419`		`- throw new ArgumentException(string.Format("Host not found: {0}", p));`
	`421`	`+ throw new ArgumentException($"Host not found: {p}");`
`420`	`422`	`}`
`421`	`423`	`}`
`422`	`424`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public static class TypeExtensions`
`55`	`55`	`/// </summary>`
`56`	`56`	`public static bool IsNullOrBlank(this string s)`
`57`	`57`	`{`
`58`		`- if (s == null \|\| s.Trim(WhiteSpaceChars).Length == 0)`
	`58`	`+ if (s == null \|\| s.AsSpan().Trim(WhiteSpaceChars).Length == 0)`
`59`	`59`	`{`
`60`	`60`	`return true;`
`61`	`61`	`}`
`@@ -65,7 +65,7 @@ public static bool IsNullOrBlank(this string s)`
`65`	`65`
`66`	`66`	`public static bool NotNullOrBlank(this string s)`
`67`	`67`	`{`
`68`		`- if (s == null \|\| s.Trim(WhiteSpaceChars).Length == 0)`
	`68`	`+ if (s == null \|\| s.AsSpan().Trim(WhiteSpaceChars).Length == 0)`
`69`	`69`	`{`
`70`	`70`	`return false;`
`71`	`71`	`}`
`@@ -206,13 +206,11 @@ public static byte[] ParseHexStr(string hexStr)`
`206`	`206`	`return buffer.ToArray();`
`207`	`207`	`}`
`208`	`208`
`209`		`- //#if NET472 \|\| NETSTANDARD2_0`
`210`	`209`	`public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple, out T1 key, out T2 value)`
`211`	`210`	`{`
`212`	`211`	`key = tuple.Key;`
`213`	`212`	`value = tuple.Value;`
`214`	`213`	`}`
`215`		`- //#endif`
`216`	`214`
`217`	`215`	`public static bool IsPrivate(this IPAddress address)`
`218`	`216`	`{`