Add static char helpers like IsAsciiHexDigit (#8417)

## Summary of changes

Vendors standard .NET 7+ `char`/ASCII helpers, and uses them where
appropriate

## Reason for change

Was duplicating these standard methods in various places, I was going to
be adding more, seemed a good time to explicitly vendor these properly.

## Implementation details

- Based on static `char` helpers methods that are available in .NET 7+
- Created as static extension methods, so they act as true pollyfills
- Replace the handrolled versions
- Replace similar methods - this isn't exhaustive, and there are some
potential alternative places, but they're used in places where we
pattern match explicitly, and didn't want to get too much into
refactoring. We can address them later as we see fit.
- _Didn't_ mark these for agressive inlining, because they're not marked
as such in the runtime, and I trust the .NET team more than my own gut 😄

## Test coverage

Added a few simple "exhaustive" unit tests for the behaviour.

## Other details

Pre-requisite for client-side-stats improvements. Part of a stack

Author: andrewlock

tracer/src/Datadog.Trace/Ci/CiEnvironment/CIEnvironmentValues.cs

@@ -191,11 +191,7 @@ protected static bool IsHex(IEnumerable<char> chars)
     {
         foreach (var c in chars)
         {
-            var isHex = (c is >= '0' and <= '9' ||
-                         c is >= 'a' and <= 'f' ||
-                         c is >= 'A' and <= 'F');
-
-            if (!isHex)
+            if (!char.IsAsciiHexDigit(c))
             {
                 return false;
             }

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/IbmMq/IbmMqHeadersAdapter.cs

@@ -5,6 +5,7 @@
 
 #nullable enable
 
+using System;
 using System.Collections.Generic;
 using System.Text;
 using Datadog.Trace.Headers;
@@ -32,7 +33,7 @@ private static string NormalizeName(string name)
         var sb = StringBuilderCache.Acquire(name.Length);
         foreach (var c in name)
         {
-            sb.Append(c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z') or (>= '0' and <= '9') ? c : '_');
+            sb.Append(char.IsAsciiLetterOrDigit(c) ? c : '_');
         }
 
         return StringBuilderCache.GetStringAndRelease(sb);

tracer/src/Datadog.Trace/Processors/TraceUtil.cs

@@ -3,6 +3,7 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
 // </copyright>
 
+using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -210,20 +211,6 @@ public static string NormalizeTag(string value)
             return new string(segment.Array, segment.Offset, segment.Count);
         }
 
-        // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L213-L216
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool IsAlpha(char c)
-        {
-            return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-        }
-
-        // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L218-L221
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool IsAlphaNumeric(char c)
-        {
-            return IsAlpha(c) || (c >= '0' && c <= '9');
-        }
-
         // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L223-L274
         public static string NormalizeMetricName(string name, int limit)
         {
@@ -236,7 +223,7 @@ public static string NormalizeMetricName(string name, int limit)
             int i = 0;
 
             // skip non-alphabetic characters
-            for (; i < name.Length && !IsAlpha(name[i]); i++) { }
+            for (; i < name.Length && !char.IsAsciiLetter(name[i]); i++) { }
 
             // if there were no alphabetic characters it wasn't valid
             if (i == name.Length)
@@ -248,7 +235,7 @@ public static string NormalizeMetricName(string name, int limit)
             {
                 char c = name[i];
 
-                if (IsAlphaNumeric(c))
+                if (char.IsAsciiLetterOrDigit(c))
                 {
                     sb.Append(c);
                 }

tracer/src/Datadog.Trace/RemoteConfigurationManagement/RemoteConfigurationPath.cs

@@ -52,7 +52,7 @@ public static RemoteConfigurationPath FromPath(string path)
                 // Verify all characters between are digits
                 for (var i = digitStart; i < secondSlash; i++)
                 {
-                    if (path[i] is < '0' or > '9')
+                    if (!char.IsAsciiDigit(path[i]))
                     {
                         ThrowHelper.ThrowException($"Error parsing path: {path}");
                     }

tracer/src/Datadog.Trace/Telemetry/Collectors/DependencyTelemetryCollector.cs

@@ -169,7 +169,7 @@ private static bool IsHexString(string assemblyName, int start)
         {
             for (int i = assemblyName.Length - 1; i >= start; i--)
             {
-                if (!IsHexChar(assemblyName[i]))
+                if (!char.IsAsciiHexDigit(assemblyName[i]))
                 {
                     return false;
                 }
@@ -194,16 +194,6 @@ private static bool IsGuid(string assemblyName)
             }
         }
 
-        private static bool IsHexChar(char c)
-        {
-            return c switch
-            {
-                >= '0' and <= '9' => true,
-                >= 'a' and <= 'f' => true,
-                _ => false
-            };
-        }
-
         private static bool IsZeroVersionAssemblyPattern(string assemblyName)
         {
             // e.g.
@@ -255,7 +245,7 @@ private static bool IsDynamicClassesPattern(string assemblyName)
             // Verify remaining characters are all digits
             for (int i = 14; i < assemblyName.Length; i++)
             {
-                if (assemblyName[i] is < '0' or > '9')
+                if (!char.IsAsciiDigit(assemblyName[i]))
                 {
                     return false;
                 }

tracer/src/Datadog.Trace/Util/CharHelpers.cs

@@ -0,0 +1,73 @@
+// <copyright file="CharHelpers.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+// Based on https://github.com/dotnet/runtime/blob/v10.0.105/src/libraries/System.Private.CoreLib/src/System/Char.cs
+
+using Datadog.Trace.Util;
+
+#if !NET7_0_OR_GREATER
+
+#nullable enable
+
+// Putting these in System, because they are polyfills for methods available directly on char in newer frameworks
+
+// ReSharper disable once CheckNamespace
+namespace System;
+
+internal static class CharHelpers
+{
+    extension(char)
+    {
+        /// <summary>Indicates whether a character is categorized as an ASCII letter.</summary>
+        /// <param name="c">The character to evaluate.</param>
+        /// <returns>true if <paramref name="c"/> is an ASCII letter; otherwise, false.</returns>
+        /// <remarks>
+        /// This determines whether the character is in the range 'A' through 'Z', inclusive,
+        /// or 'a' through 'z', inclusive.
+        /// </remarks>
+        public static bool IsAsciiLetter(char c) => (uint)((c | 0x20) - 'a') <= 'z' - 'a';
+
+        /// <summary>Indicates whether a character is categorized as an ASCII digit.</summary>
+        /// <param name="c">The character to evaluate.</param>
+        /// <returns>true if <paramref name="c"/> is an ASCII digit; otherwise, false.</returns>
+        /// <remarks>
+        /// This determines whether the character is in the range '0' through '9', inclusive.
+        /// </remarks>
+        public static bool IsAsciiDigit(char c) => IsBetween(c, '0', '9');
+
+        /// <summary>Indicates whether a character is categorized as an ASCII letter or digit.</summary>
+        /// <param name="c">The character to evaluate.</param>
+        /// <returns>true if <paramref name="c"/> is an ASCII letter or digit; otherwise, false.</returns>
+        /// <remarks>
+        /// This determines whether the character is in the range 'A' through 'Z', inclusive,
+        /// 'a' through 'z', inclusive, or '0' through '9', inclusive.
+        /// </remarks>
+        public static bool IsAsciiLetterOrDigit(char c) => IsAsciiLetter(c) | IsBetween(c, '0', '9');
+
+        /// <summary>Indicates whether a character is categorized as an ASCII hexadecimal digit.</summary>
+        /// <param name="c">The character to evaluate.</param>
+        /// <returns>true if <paramref name="c"/> is a hexadecimal digit; otherwise, false.</returns>
+        /// <remarks>
+        /// This determines whether the character is in the range '0' through '9', inclusive,
+        /// 'A' through 'F', inclusive, or 'a' through 'f', inclusive.
+        /// </remarks>
+        public static bool IsAsciiHexDigit(char c) => HexConverter.IsHexChar(c);
+
+        /// <summary>Indicates whether a character is within the specified inclusive range.</summary>
+        /// <param name="c">The character to evaluate.</param>
+        /// <param name="minInclusive">The lower bound, inclusive.</param>
+        /// <param name="maxInclusive">The upper bound, inclusive.</param>
+        /// <returns>true if <paramref name="c"/> is within the specified range; otherwise, false.</returns>
+        /// <remarks>
+        /// The method does not validate that <paramref name="maxInclusive"/> is greater than or equal
+        /// to <paramref name="minInclusive"/>.  If <paramref name="maxInclusive"/> is less than
+        /// <paramref name="minInclusive"/>, the behavior is undefined.
+        /// </remarks>
+        public static bool IsBetween(char c, char minInclusive, char maxInclusive) =>
+            (uint)(c - minInclusive) <= (uint)(maxInclusive - minInclusive);
+    }
+}
+#endif
+

tracer/test/Datadog.Trace.Tests/Util/CharHelpersTests.cs

@@ -0,0 +1,99 @@
+// <copyright file="CharHelpersTests.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+// Based on https://github.com/dotnet/runtime/blob/v10.0.105/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/CharTests.cs
+
+using System;
+using System.Linq;
+using FluentAssertions;
+using Xunit;
+
+namespace Datadog.Trace.Tests.Util;
+
+public class CharHelpersTests
+{
+    private static readonly char[] UppercaseLetters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
+    private static readonly char[] LowercaseLetters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
+    private static readonly char[] Digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+    private static readonly char[] HexDigits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'];
+
+    [Fact]
+    public static void IsAsciiLetter()
+    {
+        for (int i = char.MinValue; i <= char.MaxValue; i++)
+        {
+            var c = (char)i;
+
+            var expected = UppercaseLetters.Contains(c) || LowercaseLetters.Contains(c);
+
+            CharHelpers.IsAsciiLetter(c).Should().Be(expected);
+        }
+    }
+
+    [Fact]
+    public static void IsAsciiLetterOrDigit()
+    {
+        for (int i = char.MinValue; i <= char.MaxValue; i++)
+        {
+            var c = (char)i;
+
+            var expected = UppercaseLetters.Contains(c) || LowercaseLetters.Contains(c) ||  Digits.Contains(c);
+
+            CharHelpers.IsAsciiLetterOrDigit(c).Should().Be(expected);
+        }
+    }
+
+    [Fact]
+    public static void IsAsciiDigit()
+    {
+        for (int i = char.MinValue; i <= char.MaxValue; i++)
+        {
+            var c = (char)i;
+
+            var expected = Digits.Contains(c);
+
+            CharHelpers.IsAsciiDigit(c).Should().Be(expected);
+        }
+    }
+
+    [Fact]
+    public static void IsAsciiHexDigit()
+    {
+        for (int i = char.MinValue; i <= char.MaxValue; i++)
+        {
+            var c = (char)i;
+
+            var expected = HexDigits.Contains(c);
+
+            CharHelpers.IsAsciiHexDigit(c).Should().Be(expected);
+        }
+    }
+
+    [Theory]
+    [InlineData('a', 'a', 'a', true)]
+    [InlineData((char)('a' - 1), 'a', 'a', false)]
+    [InlineData((char)('a' + 1), 'a', 'a', false)]
+    [InlineData('a', 'a', 'b', true)]
+    [InlineData('b', 'a', 'b', true)]
+    [InlineData((char)('a' - 1), 'a', 'b', false)]
+    [InlineData((char)('b' + 1), 'a', 'b', false)]
+    [InlineData('a', 'a', 'z', true)]
+    [InlineData('m', 'a', 'z', true)]
+    [InlineData('z', 'a', 'z', true)]
+    [InlineData((char)('a' - 1), 'a', 'z', false)]
+    [InlineData((char)('z' + 1), 'a', 'z', false)]
+    [InlineData('\0', '\0', '\uFFFF', true)]
+    [InlineData('\u1234', '\0', '\uFFFF', true)]
+    [InlineData('\uFFFF', '\0', '\uFFFF', true)]
+    [InlineData('\u1234', '\u0123', '\u2345', true)]
+    [InlineData('\u1234', '\u2345', '\uFFFF', false)]
+    [InlineData('\u1234', '\u0123', '\u1233', false)]
+    [InlineData('\u1234', '\u0123', '\u1234', true)]
+    [InlineData('b', 'c', 'd', false)]
+    public static void IsBetween_Char(char c, char minInclusive, char maxInclusive, bool expected)
+    {
+        CharHelpers.IsBetween(c, minInclusive, maxInclusive).Should().Be(expected);
+    }
+}