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 twicedLength = length * 2;
+
+            if (destination.Length < twicedLength)
+                goto FalseResult;
+
+            HexConverter.EncodeToUtf16(source, destination);
+            charsWritten = twicedLength;
+            return true;
+
+            FalseResult:
+                charsWritten = 0;
+                return false;
+        }
     }  // class Convert
 }  // namespace

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

@@ -34,73 +34,50 @@ public static void CompleteValueRange()
 
         private static void TestSequence(byte[] expected, string actual)
         {
-            Assert.Equal(expected, Convert.FromHexString(actual));
-        }
+            byte[] fromResult = Convert.FromHexString(actual);
+            Assert.Equal(expected, fromResult);
 
-        [Fact]
-        public static void InvalidInputString_Null()
-        {
-            AssertExtensions.Throws<ArgumentNullException>("s", () => Convert.FromHexString(null));
-        }
+            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_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"));
-        }
-
-        [Fact]
-        public static void InvalidInputString_ZeroWidthSpace()
-        {
-            Assert.Throws<FormatException>(() => Convert.FromHexString("\u200B 000102FDFEFF"));
-        }
-
-        [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]