Spanified WebEncoders.Base64UrlEncode with string return

Author: gfoidl

src/Shared/WebEncoders/WebEncoders.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Buffers;
 using System.Diagnostics;
 using System.Globalization;
 using Microsoft.Extensions.WebEncoders.Sources;
@@ -189,6 +190,36 @@ public static int GetArraySizeRequiredToDecode(int count)
             return checked(count + numPaddingCharsToAdd);
         }
 
+        /// <summary>
+        /// Encodes <paramref name="input"/> using base64url encoding.
+        /// </summary>
+        /// <param name="input">The binary input to encode.</param>
+        /// <returns>The base64url-encoded form of <paramref name="input"/>.</returns>
+        public static string Base64UrlEncode(ReadOnlySpan<byte> input)
+        {
+            if (input.IsEmpty)
+            {
+                return string.Empty;
+            }
+
+            int bufferSize = GetArraySizeRequiredToEncode(input.Length);
+
+            char[] bufferToReturnToPool = null;
+            Span<char> buffer = bufferSize <= 128
+                ? stackalloc char[bufferSize]
+                : bufferToReturnToPool = ArrayPool<char>.Shared.Rent(bufferSize);
+
+            var numBase64Chars = Base64UrlEncode(input, buffer);
+            var base64Url = new string(buffer.Slice(0, numBase64Chars));
+
+            if (bufferToReturnToPool != null)
+            {
+                ArrayPool<char>.Shared.Return(bufferToReturnToPool);
+            }
+
+            return base64Url;
+        }
+
         /// <summary>
         /// Encodes <paramref name="input"/> using base64url encoding.
         /// </summary>
@@ -220,16 +251,7 @@ public static string Base64UrlEncode(byte[] input, int offset, int count)
 
             ValidateParameters(input.Length, nameof(input), offset, count);
 
-            // Special-case empty input
-            if (count == 0)
-            {
-                return string.Empty;
-            }
-
-            var buffer = new char[GetArraySizeRequiredToEncode(count)];
-            var numBase64Chars = Base64UrlEncode(input, offset, buffer, outputOffset: 0, count: count);
-
-            return new String(buffer, startIndex: 0, length: numBase64Chars);
+            return Base64UrlEncode(input.AsSpan(offset, count));
         }
 
         /// <summary>
@@ -280,19 +302,38 @@ public static int Base64UrlEncode(byte[] input, int offset, char[] output, int o
                     nameof(count));
             }
 
-            // Special-case empty input.
-            if (count == 0)
+            return Base64UrlEncode(input.AsSpan(offset, count), output.AsSpan(outputOffset));
+        }
+
+        /// <summary>
+        /// Get the minimum output <c>char[]</c> size required for encoding <paramref name="count"/>
+        /// <see cref="byte"/>s with the <see cref="Base64UrlEncode(byte[], int, char[], int, int)"/> method.
+        /// </summary>
+        /// <param name="count">The number of characters to encode.</param>
+        /// <returns>
+        /// The minimum output <c>char[]</c> size required for encoding <paramref name="count"/> <see cref="byte"/>s.
+        /// </returns>
+        public static int GetArraySizeRequiredToEncode(int count)
+        {
+            var numWholeOrPartialInputBlocks = checked(count + 2) / 3;
+            return checked(numWholeOrPartialInputBlocks * 4);
+        }
+
+        private static int Base64UrlEncode(ReadOnlySpan<byte> input, Span<char> output)
+        {
+            Debug.Assert(output.Length >= GetArraySizeRequiredToEncode(input.Length));
+
+            if (input.IsEmpty)
             {
                 return 0;
             }
 
             // Use base64url encoding with no padding characters. See RFC 4648, Sec. 5.
 
-            // Start with default Base64 encoding.
-            var numBase64Chars = Convert.ToBase64CharArray(input, offset, count, output, outputOffset);
+            Convert.TryToBase64Chars(input, output, out int charsWritten);
 
             // Fix up '+' -> '-' and '/' -> '_'. Drop padding characters.
-            for (var i = outputOffset; i - outputOffset < numBase64Chars; i++)
+            for (var i = 0; i < charsWritten; i++)
             {
                 var ch = output[i];
                 if (ch == '+')
@@ -306,25 +347,11 @@ public static int Base64UrlEncode(byte[] input, int offset, char[] output, int o
                 else if (ch == '=')
                 {
                     // We've reached a padding character; truncate the remainder.
-                    return i - outputOffset;
+                    return i;
                 }
             }
 
-            return numBase64Chars;
-        }
-
-        /// <summary>
-        /// Get the minimum output <c>char[]</c> size required for encoding <paramref name="count"/>
-        /// <see cref="byte"/>s with the <see cref="Base64UrlEncode(byte[], int, char[], int, int)"/> method.
-        /// </summary>
-        /// <param name="count">The number of characters to encode.</param>
-        /// <returns>
-        /// The minimum output <c>char[]</c> size required for encoding <paramref name="count"/> <see cref="byte"/>s.
-        /// </returns>
-        public static int GetArraySizeRequiredToEncode(int count)
-        {
-            var numWholeOrPartialInputBlocks = checked(count + 2) / 3;
-            return checked(numWholeOrPartialInputBlocks * 4);
+            return charsWritten;
         }
 
         private static int GetNumBase64PaddingCharsInString(string str)