Convert.Try{From/To}HexString

src/libraries/System.Private.CoreLib/src/System/Convert.cs

@@ -2960,6 +2960,65 @@ public static byte[] FromHexString(ReadOnlySpan<char> chars)
             return result;
         }
 
+        /// <summary>
+        /// Converts the string, which encodes binary data as hex characters, to an equivalent 8-bit unsigned integer span.
+        /// </summary>
+        /// <param name="source">The string to convert.</param>
+        /// <param name="destination">
+        /// The span in which to write the converted 8-bit unsigned integers. When this method returns false,
+        /// either the span remains unmodified or contains an incomplete conversion of <paramref name="source"/>,
+        /// up to the last valid character.
+        /// </param>
+        /// <param name="bytesWritten">When this method returns, contains the number of bytes that were written in <paramref name="destination"/>.</param>
+        /// <returns>true if the conversion was successful; otherwise, false.</returns>
+        /// <exception cref="ArgumentNullException">Passed string <paramref name="source"/> is null.</exception>
+        public static bool TryFromHexString(string source, Span<byte> destination, out int bytesWritten)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            return TryFromHexString(source.AsSpan(), destination, out bytesWritten);
+        }
+
+        /// <summary>
+        /// Converts the span of chars, which encodes binary data as hex characters, to an equivalent 8-bit unsigned integer span.
+        /// </summary>
+        /// <param name="source">The span to convert.</param>
+        /// <param name="destination">
+        /// The span in which to write the converted 8-bit unsigned integers. When this method returns false,
+        /// either the span remains unmodified or contains an incomplete conversion of <paramref name="source"/>,
+        /// up to the last valid character.
+        /// </param>
+        /// <param name="bytesWritten">When this method returns, contains the number of bytes that were written in <paramref name="destination"/>.</param>
+        /// <returns>true if the conversion was successful; otherwise, false.</returns>
+        public static bool TryFromHexString(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten)
+        {
+            var length = source.Length;
+
+            if (length % 2 != 0)
+                goto FalseResult;
+
+            if (length == 0)
+            {
+                bytesWritten = 0;
+                return true;
+            }
+
+            var halfLength = length / 2;
+
+            if (destination.Length < halfLength)
+                goto FalseResult;
+
+            if (!HexConverter.TryDecodeFromUtf16(source, destination))
+                goto FalseResult;
+
+            bytesWritten = halfLength;
+            return true;
+
+            FalseResult:
+                bytesWritten = 0;
+                return false;
+        }
+
         /// <summary>
         /// Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with uppercase hex characters.
         /// </summary>
@@ -3011,5 +3070,40 @@ public static string ToHexString(ReadOnlySpan<byte> bytes)
 
             return HexConverter.ToString(bytes, HexConverter.Casing.Upper);
         }
+
+
+        /// <summary>
+        /// Converts a span of 8-bit unsigned integers to its equivalent span representation that is encoded with uppercase hex characters.
+        /// </summary>
+        /// <param name="source">A span of 8-bit unsigned integers.</param>
+        /// <param name="destination">The span representation in hex of the elements in <paramref name="source"/>.</param>
+        /// <param name="charsWritten">When this method returns, contains the number of chars that were written in <paramref name="destination"/>.</param>
+        /// <returns>true if the conversion was successful; otherwise, false.</returns>
+        public static bool TryToHexString(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten)
+        {
+            var length = source.Length;
+
+            if (length > int.MaxValue / 2)
+                goto FalseResult;
+
+            if (length == 0)
+            {
+                charsWritten = 0;
+                return true;
+            }
+
+            int twiceLength = length * 2;
+
+            if (destination.Length < twiceLength)
+                goto FalseResult;
+
+            HexConverter.EncodeToUtf16(source, destination);
+            charsWritten = twiceLength;
+            return true;
+
+            FalseResult:
+                charsWritten = 0;
+                return false;
+        }
     }  // class Convert
 }  // namespace

src/libraries/System.Runtime.Extensions/tests/System/Convert.FromHexString.cs

@@ -34,90 +34,80 @@ public static void CompleteValueRange()
 
         private static void TestSequence(byte[] expected, string actual)
         {
-            Assert.Equal(expected, Convert.FromHexString(actual));
-        }
-
-        [Fact]
-        public static void InvalidInputString_Null()
-        {
-            AssertExtensions.Throws<ArgumentNullException>("s", () => Convert.FromHexString(null));
-        }
-
-        [Fact]
-        public static void InvalidInputString_HalfByte()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("ABC"));
-        }
-
-        [Fact]
-        public static void InvalidInputString_BadFirstCharacter()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("x0"));
-        }
-
-        [Fact]
-        public static void InvalidInputString_BadSecondCharacter()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("0x"));
-        }
-
-        [Fact]
-        public static void InvalidInputString_NonAsciiCharacter()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("0\u0308"));
-        }
+            byte[] fromResult = Convert.FromHexString(actual);
+            Assert.Equal(expected, fromResult);
 
-        [Fact]
-        public static void InvalidInputString_ZeroWidthSpace()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("\u200B 000102FDFEFF"));
-        }
+            Span<byte> tryResult = stackalloc byte[actual.Length / 2];
+            Assert.True(Convert.TryFromHexString(actual, tryResult, out int written));
+            Assert.Equal(fromResult.Length, written);
+            AssertExtensions.SequenceEqual(expected, tryResult);
 
-        [Fact]
-        public static void InvalidInputString_LeadingWhiteSpace()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("  000102FDFEFF"));
         }
 
         [Fact]
-        public static void InvalidInputString_TrailingWhiteSpace()
+        public static void InvalidInputString_Null()
         {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("000102FDFEFF  "));
+            AssertExtensions.Throws<ArgumentNullException>("s", () => Convert.FromHexString(null));
+            Assert.False(Convert.TryFromHexString(null, default, out _));
         }
 
-        [Fact]
-        public static void InvalidInputString_WhiteSpace()
+        [Theory]
+        [InlineData("01-02-FD-FE-FF")]
+        [InlineData("00 01 02FD FE FF")]
+        [InlineData("000102FDFEFF  ")]
+        [InlineData("  000102FDFEFF")]
+        [InlineData("\u200B 000102FDFEFF")]
+        [InlineData("0\u0308")]
+        [InlineData("0x")]
+        [InlineData("x0")]
+        [InlineData("ABC")] // HalfByte
+        public static void InvalidInputString_FormatException_Or_FalseResult(string invalidInput)
         {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("00 01 02FD FE FF"));
-        }
+            Assert.Throws<FormatException>(() => Convert.FromHexString(invalidInput));
 
-        [Fact]
-        public static void InvalidInputString_Dash()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("01-02-FD-FE-FF"));
+            Span<byte> buffer = stackalloc byte[invalidInput.Length / 2];
+            Assert.False(Convert.TryFromHexString(invalidInput.AsSpan(), buffer, out _));
         }
 
         [Fact]
         public static void ZeroLength()
         {
             Assert.Same(Array.Empty<byte>(), Convert.FromHexString(string.Empty));
+
+            bool tryResult = Convert.TryFromHexString(string.Empty, Span<byte>.Empty, out int written);
+
+            Assert.True(tryResult);
+            Assert.Equal(0, written);
         }
 
         [Fact]
         public static void ToHexFromHexRoundtrip()
         {
-            for (int i = 1; i < 50; i++)
+            const int LoopCount = 50;
+            Span<char> buffer = stackalloc char[LoopCount * 2];
+            for (int i = 1; i < LoopCount; i++)
             {
-                byte[] data = System.Security.Cryptography.RandomNumberGenerator.GetBytes(i);
+                byte[] data = Security.Cryptography.RandomNumberGenerator.GetBytes(i);
                 string hex = Convert.ToHexString(data);
-                Assert.Equal(data, Convert.FromHexString(hex.ToLowerInvariant()));
-                Assert.Equal(data, Convert.FromHexString(hex.ToUpperInvariant()));
+
+                Span<char> currentBuffer = buffer.Slice(0, i);
+                bool tryHex = Convert.TryToHexString(data, currentBuffer, out int written);
+                Assert.True(tryHex);
+                AssertExtensions.SequenceEqual(hex.AsSpan(), currentBuffer);
+                Assert.Equal(hex.Length, written);
+
+                TestSequence(data, hex);
+                TestSequence(data, hex.ToLowerInvariant());
+                TestSequence(data, hex.ToUpperInvariant());
+
                 string mixedCase1 = hex.Substring(0, hex.Length / 2).ToUpperInvariant() +
                                     hex.Substring(hex.Length / 2).ToLowerInvariant();
                 string mixedCase2 = hex.Substring(0, hex.Length / 2).ToLowerInvariant() +
                                     hex.Substring(hex.Length / 2).ToUpperInvariant();
-                Assert.Equal(data, Convert.FromHexString(mixedCase1));
-                Assert.Equal(data, Convert.FromHexString(mixedCase2));
+
+                TestSequence(data, mixedCase1);
+                TestSequence(data, mixedCase2);
+
                 Assert.Throws<FormatException>(() => Convert.FromHexString(hex + "  "));
                 Assert.Throws<FormatException>(() => Convert.FromHexString("\uAAAA" + hex));
             }

src/libraries/System.Runtime/ref/System.Runtime.cs

@@ -1119,7 +1119,9 @@ public static partial class Convert
         public static byte[] FromBase64CharArray(char[] inArray, int offset, int length) { throw null; }
         public static byte[] FromBase64String(string s) { throw null; }
         public static byte[] FromHexString(System.ReadOnlySpan<char> chars) { throw null; }
+        public static bool TryFromHexString(System.ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten) { throw null; }
         public static byte[] FromHexString(string s) { throw null; }
+        public static bool TryFromHexString(string source, Span<byte> destination, out int bytesWritten) { throw null; }
         public static System.TypeCode GetTypeCode(object? value) { throw null; }
         public static bool IsDBNull([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut) { throw null; }
@@ -1265,6 +1267,7 @@ public static partial class Convert
         public static string ToHexString(byte[] inArray) { throw null; }
         public static string ToHexString(byte[] inArray, int offset, int length) { throw null; }
         public static string ToHexString(System.ReadOnlySpan<byte> bytes) { throw null; }
+        public static bool TryToHexString(System.ReadOnlySpan<byte> source, System.Span<char> destination, out int charsWritten) { throw null; }
         public static short ToInt16(bool value) { throw null; }
         public static short ToInt16(byte value) { throw null; }
         public static short ToInt16(char value) { throw null; }