Optimize AWSSDKUtils.ToHex() for speed and memory

sdk/src/Core/Amazon.Util/AWSSDKUtils.cs

@@ -20,6 +20,7 @@
 
 using Amazon.Runtime.Internal.Util;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -761,14 +762,59 @@ public static long ConvertTimeSpanToMilliseconds(TimeSpan timeSpan)
         /// <returns>String version of the data</returns>
         public static string ToHex(byte[] data, bool lowercase)
         {
-            StringBuilder sb = new StringBuilder();
-
-            for (int i = 0; i < data.Length; i++)
+#if NET8_0_OR_GREATER
+            if (!lowercase)
             {
-                sb.Append(data[i].ToString(lowercase ? "x2" : "X2", CultureInfo.InvariantCulture));
+                return Convert.ToHexString(data);
             }
+#endif
 
-            return sb.ToString();
+#if NETCOREAPP3_1_OR_GREATER
+            Func<int, char> converter = lowercase ? (Func<int, char>)ToLowerHex : (Func<int, char>)ToUpperHex;
+
+            return string.Create(data.Length * 2, (data, converter), (chars, state) =>
+            {
+                byte[] data = state.data;
+                Func<int, char> converter = state.converter;
+
+                for (int i = data.Length - 1; i >= 0; i--)
+                {
+                    // Break apart the byte into two four-bit components and
+                    // then convert each into their hexadecimal equivalent.
+                    byte b = data[i];
+                    int hiNibble = b >> 4;
+                    int loNibble = b & 0xF;
+
+                    chars[i * 2] = converter(hiNibble);
+                    chars[i * 2 + 1] = converter(loNibble);
+                }
+            });
+#else
+            char[] chars = ArrayPool<char>.Shared.Rent(data.Length * 2);
+
+            try
+            {
+                Func<int, char> converter = lowercase ? (Func<int, char>)ToLowerHex : (Func<int, char>)ToUpperHex;
+
+                for (int i = data.Length - 1; i >= 0; i--)
+                {
+                    // Break apart the byte into two four-bit components and
+                    // then convert each into their hexadecimal equivalent.
+                    byte b = data[i];
+                    int hiNibble = b >> 4;
+                    int loNibble = b & 0xF;
+
+                    chars[i * 2] = converter(hiNibble);
+                    chars[i * 2 + 1] = converter(loNibble);
+                }
+
+                return new string(chars, 0, data.Length * 2);
+            }
+            finally
+            {
+                ArrayPool<char>.Shared.Return(chars);
+            }
+#endif
         }
 
         /// <summary>
@@ -1171,7 +1217,18 @@ private static char ToUpperHex(int value)
             // Maps 10-15 to the Unicode range of 'A' - 'F' (0x41 - 0x46).
             return (char)(value - 10 + 'A');
         }
-
+
+        private static char ToLowerHex(int value)
+        {
+            // Maps 0-9 to the Unicode range of '0' - '9' (0x30 - 0x39).
+            if (value <= 9)
+            {
+                return (char)(value + '0');
+            }
+            // Maps 10-15 to the Unicode range of 'a' - 'f' (0x61 - 0x66).
+            return (char)(value - 10 + 'a');
+        }
+
         internal static string UrlEncodeSlash(string data)
         {
             if (string.IsNullOrEmpty(data))
@@ -1333,12 +1390,7 @@ public static void Sleep(TimeSpan ts)
         /// </summary>
         /// <param name="value">Bytes to convert.</param>
         /// <returns>Hexadecimal string representing the byte array.</returns>
-        public static string BytesToHexString(byte[] value)
-        {
-            string hex = BitConverter.ToString(value);
-            hex = hex.Replace("-", string.Empty);
-            return hex;
-        }
+        public static string BytesToHexString(byte[] value) => ToHex(value, false);
 
         /// <summary>
         /// Convert a hex string to bytes

sdk/test/NetStandard/UnitTests/Core/AWSSDKUtilsTests.cs

@@ -0,0 +1,40 @@
+using Amazon.Runtime;
+using Amazon.Util;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace UnitTests.NetStandard.Core
+{
+    [Trait("Category", "Core")]
+    public class AWSSDKUtilsTests
+    {
+        [Fact]
+        public void BytesToHexString()
+        {
+            var bytes = Encoding.UTF8.GetBytes("Hello World");
+            var hexString = AWSSDKUtils.BytesToHexString(bytes);
+
+            Assert.Equal("48656C6C6F20576F726C64", hexString);
+        }
+
+        [Fact]
+        public void ToHexUppercase()
+        {
+            var bytes = Encoding.UTF8.GetBytes("Hello World");
+            var hexString = AWSSDKUtils.ToHex(bytes, false);
+
+            Assert.Equal("48656C6C6F20576F726C64", hexString);
+        }
+
+        [Fact]
+        public void ToHexLowercase()
+        {
+            var bytes = Encoding.UTF8.GetBytes("Hello World");
+            var hexString = AWSSDKUtils.ToHex(bytes, true);
+
+            Assert.Equal("48656c6c6f20576f726c64", hexString);
+        }
+    }
+}