Optimize HttpUtility.UrlEncodeToBytes for (string, Encoding) overload.

Author: TrayanZapryanov

src/libraries/System.Web.HttpUtility/src/System/Web/HttpUtility.cs

@@ -216,19 +216,10 @@ public static NameValueCollection ParseQueryString(string query, Encoding encodi
         public static byte[]? UrlDecodeToBytes(byte[]? bytes) => bytes == null ? null : HttpEncoder.UrlDecode(bytes.AsSpan(0, bytes.Length));
 
         [return: NotNullIfNotNull(nameof(str))]
-        public static byte[]? UrlEncodeToBytes(string? str, Encoding e)
-        {
-            if (str == null)
-            {
-                return null;
-            }
-
-            byte[] bytes = e.GetBytes(str);
-            return HttpEncoder.UrlEncode(bytes, 0, bytes.Length, alwaysCreateNewReturnValue: false);
-        }
+        public static byte[]? UrlEncodeToBytes(string? str, Encoding e) => str == null ? null : HttpEncoder.UrlEncode(str, e);
 
         [return: NotNullIfNotNull(nameof(bytes))]
-        public static byte[]? UrlEncodeToBytes(byte[]? bytes, int offset, int count) => HttpEncoder.UrlEncode(bytes, offset, count, alwaysCreateNewReturnValue: true);
+        public static byte[]? UrlEncodeToBytes(byte[]? bytes, int offset, int count) => HttpEncoder.UrlEncode(bytes, offset, count);
 
         [Obsolete("This method produces non-standards-compliant output and has interoperability issues. The preferred alternative is UrlEncode(String).")]
         [return: NotNullIfNotNull(nameof(str))]

src/libraries/System.Web.HttpUtility/src/System/Web/Util/HttpEncoder.cs

@@ -401,64 +401,37 @@ internal static string UrlDecode(ReadOnlySpan<char> value, Encoding encoding)
         }
 
         [return: NotNullIfNotNull(nameof(bytes))]
-        internal static byte[]? UrlEncode(byte[]? bytes, int offset, int count, bool alwaysCreateNewReturnValue)
-        {
-            byte[]? encoded = UrlEncode(bytes, offset, count);
-
-            return (alwaysCreateNewReturnValue && (encoded != null) && (encoded == bytes))
-                ? (byte[])encoded.Clone()
-                : encoded;
-        }
-
-        [return: NotNullIfNotNull(nameof(bytes))]
-        private static byte[]? UrlEncode(byte[]? bytes, int offset, int count)
+        internal static byte[]? UrlEncode(byte[]? bytes, int offset, int count)
         {
             if (!ValidateUrlEncodingParameters(bytes, offset, count))
             {
                 return null;
             }
 
-            int cSpaces = 0;
-            int cUnsafe = 0;
-
-            // count them first
-            for (int i = 0; i < count; i++)
-            {
-                char ch = (char)bytes[offset + i];
-
-                if (ch == ' ')
-                {
-                    cSpaces++;
-                }
-                else if (!HttpEncoderUtility.IsUrlSafeChar(ch))
-                {
-                    cUnsafe++;
-                }
-            }
+            return UrlEncode(bytes.AsSpan(offset, count));
+        }
 
+        private static byte[] UrlEncode(ReadOnlySpan<byte> bytes)
+        {
             // nothing to expand?
-            if (cSpaces == 0 && cUnsafe == 0)
+            if (!IsExpandingNeeded(bytes, out int cUnsafe))
             {
-                // DevDiv 912606: respect "offset" and "count"
-                if (0 == offset && bytes.Length == count)
-                {
-                    return bytes;
-                }
-                else
-                {
-                    byte[] subarray = new byte[count];
-                    Buffer.BlockCopy(bytes, offset, subarray, 0, count);
-                    return subarray;
-                }
+                return bytes.ToArray();
             }
 
+            return UrlEncode(bytes, cUnsafe);
+        }
+
+        private static byte[] UrlEncode(ReadOnlySpan<byte> bytes, int cUnsafe)
+        {
+            int count = bytes.Length;
             // expand not 'safe' characters into %XX, spaces to +s
             byte[] expandedBytes = new byte[count + cUnsafe * 2];
             int pos = 0;
 
             for (int i = 0; i < count; i++)
             {
-                byte b = bytes[offset + i];
+                byte b = bytes[i];
                 char ch = (char)b;
 
                 if (HttpEncoderUtility.IsUrlSafeChar(ch))
@@ -480,6 +453,51 @@ internal static string UrlDecode(ReadOnlySpan<char> value, Encoding encoding)
             return expandedBytes;
         }
 
+        private static bool IsExpandingNeeded(ReadOnlySpan<byte> bytes, out int cUnsafe)
+        {
+            cUnsafe = 0;
+
+            int cSpaces = 0;
+            int count = bytes.Length;
+            for (int i = 0; i < count; i++)
+            {
+                char ch = (char)bytes[i];
+
+                if (ch == ' ')
+                {
+                    cSpaces++;
+                }
+                else if (!HttpEncoderUtility.IsUrlSafeChar(ch))
+                {
+                    cUnsafe++;
+                }
+            }
+
+            return cSpaces != 0 || cUnsafe != 0;
+        }
+
+        internal static byte[] UrlEncode(string str, Encoding e)
+        {
+            const int StackallocThreshold = 512;
+
+            if (e.GetMaxByteCount(str.Length) <= StackallocThreshold)
+            {
+                Span<byte> byteSpan = stackalloc byte[StackallocThreshold];
+                int encodedBytes = e.GetBytes(str, byteSpan);
+
+                return UrlEncode(byteSpan.Slice(0, encodedBytes));
+            }
+
+            byte[] bytes = e.GetBytes(str);
+            if (!IsExpandingNeeded(bytes, out int cUnsafe))
+            {
+                // return encoded byte[] if nothing to expand
+                return bytes;
+            }
+
+            return UrlEncode(bytes.AsSpan(0, bytes.Length), cUnsafe);
+        }
+
         //  Helper to encode the non-ASCII url characters only
         private static string UrlEncodeNonAscii(string str, Encoding e)
         {