Optimize HttpUtility.UrlPathEncode allocations.

[TrayanZapryanov]

1. Omit intermediate string allocations by using Ranges.
2. Use stackalloc arrays when input is small enough for encoding and ASCII conversions.
3. Remove string.Contains(' ') loop.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/ncl
See info in area-owners.md if you want to be subscribed.

[TrayanZapryanov]

Benchmark:

[MemoryDiagnoser]
public class HttpUtilityBenchmarks
{
	[Benchmark(Baseline = true)]
	public string UrlTryCreate() => Uri.TryCreate("http://EXAMPLE.NET/d\\u00E9fault.xxx?sdsd=sds", UriKind.Absolute, out var uri) ? uri.Authority : "error";

	[Benchmark]
	public string UrlPathEncode() => HttpUtility.UrlPathEncode("http://EXAMPLE.NET/d\\u00E9fault.xxx?sdsd=sds");

	[Benchmark]
	public string UrlPathEncode_PR() => MyHttpUtility.UrlPathEncode("http://EXAMPLE.NET/d\\u00E9fault.xxx?sdsd=sds");
}

Results:

Method	Mean	Error	StdDev	Ratio	RatioSD	Gen0	Allocated	Alloc Ratio
UrlTryCreate	260.7 ns	2.41 ns	2.01 ns	1.00	0.00	0.0277	232 B	1.00
UrlPathEncode	338.5 ns	6.03 ns	5.64 ns	1.30	0.02	0.0839	704 B	3.03
UrlPathEncode_PR	325.4 ns	4.59 ns	4.30 ns	1.25	0.02	0.0658	552 B	2.38

[MihaZupan]

These methods are still allocating quite a bit (the original string even if it's already Ascii, substring and combined string in UrlPathEncodeImpl ...).

The 1 caller of this helper is using Encoding.UTF8 and wants to stop after you see a ?.
Assuming there's sufficient test coverage, I would change this to instead look something like

private static string UrlPathEncodeImpl(string value)
{
    int i = value.AsSpan().IndexOfAnyExceptInRange((char)0x21, (char)0x7F);
    if (i < 0)
    {
        return value;
    }

    int indexOfQuery = value.IndexOf('?');
    if (indexOfQuery >= 0 && indexOfQuery < i)
    {
        // Everything before the Query is valid ASCII
        return value;
    }

    ReadOnlySpan<char> toEncode = indexOfQuery >= 0
        ? value.AsSpan(i, indexOfQuery - i)
        : value.AsSpan(i);

    byte[] bytes = ArrayPool<char>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length));
    char[] chars = ArrayPool<char>.Shared.Rent(bytes.Length * 3);

    int utf8Length = Encoding.UTF8.GetBytes(toEncode, bytes);
    int charCount = 0;
    foreach (byte b in bytes.AsSpan(0, utf8Length))
    {
        if (IsNonAsciiOrSpaceByte(b))
        {
            chars[charCount++] = '%';
            chars[charCount++] = HexConverter.ToCharLower(b >> 4);
            chars[charCount++] = HexConverter.ToCharLower(b);
        }
        else
        {
            chars[charCount++] = (char)b;
        }
    }

    ArrayPool<byte>.Shared.Return(bytes);
    string result = string.Concat(
        value.AsSpan(0, i),
        chars.AsSpan(0, charCount),
        indexOfQuery >= 0 ? value.AsSpan(indexOfQuery) : ReadOnlySpan<char>.Empty);
    ArrayPool<char>.Shared.Return(chars);
    return result;
}

This would avoid a bunch of intermediate allocations and transcoding.

[MihaZupan]

Suggested change

	schemeAndAuthority = default(Range);
	path = Range.All;
	queryAndFragment = default(Range);
	return UrlPathEncodeImpl(value);

Otherwise you would end up allocating a substring for value.AsSpan(path).ToString() + a substring for the string.Concat.

[MihaZupan]

This could be combined into the whole UrlPathEncodeImpl to avoid the substring allocations

[MihaZupan]

By forcing everything into spans and ranges, you are now also allocating substrings where you might not have needed to previously. E.g. if pathRange is Range.All, you're reallocating the original string.

You could inline ExtractQueryAndFragment into this method, and always use Substring for the path portion.
I would also suggest returning Span instead of Range as it's easier to use given that the callers only need the range to make the span anyway.

[TrayanZapryanov]

@MihaZupan Sorry I messed git while trying to rebase after merging previous PRs.
Sorry for the stupid question, but can you tell me how you are updating older branches to latest version without closing existing PR.
Meanwhile I will try to open another PR with your comments integrated.

[MihaZupan]

Assuming upstream is this repo and origin is your fork, my workflow looks something like

git checkout main
git pull upstream

git checkout your-branch
git rebase main // And now fix any conflicts
git push origin -f