Remove some split/substring/trim allocations from System.Net.* (#80471)

stephentoub · web-flow · commit f9242b22a7cb · 2023-01-11T07:21:15.000-05:00
diff --git a/src/libraries/Common/src/System/Net/Security/Unix/SafeFreeNegoCredentials.cs b/src/libraries/Common/src/System/Net/Security/Unix/SafeFreeNegoCredentials.cs
@@ -37,32 +37,25 @@ public bool IsDefault
             get { return _isDefault; }
         }
 
-        public SafeFreeNegoCredentials(Interop.NetSecurityNative.PackageType packageType, string username, string password, string domain)
+        public SafeFreeNegoCredentials(Interop.NetSecurityNative.PackageType packageType, string username, string password, ReadOnlySpan<char> domain)
             : base(IntPtr.Zero, true)
         {
             Debug.Assert(username != null && password != null, "Username and Password can not be null");
-            const char At = '@';
-            const char Backwhack = '\\';
 
             // any invalid user format will not be manipulated and passed as it is.
-            int index = username.IndexOf(Backwhack);
-            if (index > 0 && username.IndexOf(Backwhack, index + 1) < 0 && string.IsNullOrEmpty(domain))
+            int index = username.IndexOf('\\');
+            if (index > 0 && username.IndexOf('\\', index + 1) < 0 && domain.IsEmpty)
             {
-                domain = username.Substring(0, index);
+                domain = username.AsSpan(0, index);
                 username = username.Substring(index + 1);
             }
 
             // remove any leading and trailing whitespace
-            if (domain != null)
-            {
-                domain = domain.Trim();
-            }
-
             username = username.Trim();
-
-            if ((username.IndexOf(At) < 0) && !string.IsNullOrEmpty(domain))
+            domain = domain.Trim();
+            if (!username.Contains('@') && !domain.IsEmpty)
             {
-                username += At + domain;
+                username = string.Concat(username, "@", domain);
             }
 
             bool ignore = false;
diff --git a/src/libraries/System.Net.HttpListener/src/System/Net/Managed/HttpListenerRequest.Managed.cs b/src/libraries/System.Net.HttpListener/src/System/Net/Managed/HttpListenerRequest.Managed.cs
@@ -31,6 +31,7 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System.Buffers;
 using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Globalization;
@@ -63,8 +64,8 @@ private sealed class Context : TransportContext
         private Stream? _inputStream;
         private HttpListenerContext _context;
         private bool _isChunked;
-
-        private static byte[] s_100continue = "HTTP/1.1 100 Continue\r\n\r\n"u8.ToArray();
+        private static readonly IndexOfAnyValues<char> s_validMethodChars = IndexOfAnyValues.Create("!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~");
+        private static readonly byte[] s_100continue = "HTTP/1.1 100 Continue\r\n\r\n"u8.ToArray();
 
         internal HttpListenerRequest(HttpListenerContext context)
         {
@@ -75,37 +76,32 @@ internal HttpListenerRequest(HttpListenerContext context)
 
         internal void SetRequestLine(string req)
         {
-            string[] parts = req.Split(' ', 3);
-            if (parts.Length != 3)
+            Span<Range> parts = stackalloc Range[3];
+            if (req.AsSpan().Split(parts, ' ') != 3)
             {
                 _context.ErrorMessage = "Invalid request line (parts).";
                 return;
             }
 
-            _method = parts[0];
-            foreach (char c in _method)
+            _method = req[parts[0]];
+            if (_method.AsSpan().IndexOfAnyExcept(s_validMethodChars) >= 0)
             {
-                if (char.IsAsciiLetterUpper(c) ||
-                    (c > 32 && c < 127 && c != '(' && c != ')' && c != '<' &&
-                     c != '<' && c != '>' && c != '@' && c != ',' && c != ';' &&
-                     c != ':' && c != '\\' && c != '"' && c != '/' && c != '[' &&
-                     c != ']' && c != '?' && c != '=' && c != '{' && c != '}'))
-                    continue;
-
                 _context.ErrorMessage = "(Invalid verb)";
                 return;
             }
 
-            _rawUrl = parts[1];
-            if (parts[2].Length != 8 || !parts[2].StartsWith("HTTP/", StringComparison.Ordinal))
+            _rawUrl = req[parts[1]];
+
+            ReadOnlySpan<char> version = req.AsSpan()[parts[2]];
+            if (version.Length != 8 || !version.StartsWith("HTTP/", StringComparison.Ordinal))
             {
                 _context.ErrorMessage = "Invalid request line (version).";
                 return;
             }
 
             try
             {
-                _version = new Version(parts[2].Substring(5));
+                _version = Version.Parse(version.Slice("HTTP/".Length));
             }
             catch
             {
@@ -231,15 +227,6 @@ internal void FinishInitialization()
             }
         }
 
-        internal static string Unquote(string str)
-        {
-            int start = str.IndexOf('\"');
-            int end = str.LastIndexOf('\"');
-            if (start >= 0 && end >= 0)
-                str = str.Substring(start + 1, end - 1);
-            return str.Trim();
-        }
-
         internal void AddHeader(string header)
         {
             int colon = header.IndexOf(':');
diff --git a/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/StringParsingHelpers.Misc.cs b/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/StringParsingHelpers.Misc.cs
@@ -101,7 +101,7 @@ internal static int ParseDefaultTtlFromFile(string filePath)
         internal static int ParseRawIntFile(string filePath)
         {
             int ret;
-            if (!int.TryParse(ReadAllText(filePath).Trim(), out ret))
+            if (!int.TryParse(ReadAllText(filePath).AsSpan().Trim(), out ret))
             {
                 throw ExceptionHelper.CreateForParseFailure();
             }
diff --git a/src/libraries/System.Net.Requests/src/System/Net/HttpWebResponse.cs b/src/libraries/System.Net.Requests/src/System/Net/HttpWebResponse.cs
@@ -272,7 +272,7 @@ public string? CharacterSet
                     string srchString = contentType.ToLowerInvariant();
 
                     //media subtypes of text type has a default as specified by rfc 2616
-                    if (srchString.Trim().StartsWith("text/", StringComparison.Ordinal))
+                    if (srchString.AsSpan().Trim().StartsWith("text/", StringComparison.Ordinal))
                     {
                         _characterSet = "ISO-8859-1";
                     }
diff --git a/src/libraries/System.Net.WebHeaderCollection/src/System.Net.WebHeaderCollection.csproj b/src/libraries/System.Net.WebHeaderCollection/src/System.Net.WebHeaderCollection.csproj
@@ -11,8 +11,6 @@
     <Compile Include="System\Net\HeaderInfoTable.cs" />
     <Compile Include="$(CommonPath)System\Net\CaseInsensitiveAscii.cs"
              Link="Common\System\Net\CaseInsensitiveAscii.cs" />
-    <Compile Include="$(CommonPath)System\StringExtensions.cs"
-             Link="Common\System\StringExtensions.cs" />
     <Compile Include="$(CommonPath)System\Net\HttpKnownHeaderNames.cs"
              Link="Common\System\Net\HttpKnownHeaderNames.cs" />
     <Compile Include="$(CommonPath)System\Net\HttpValidationHelpers.cs"
diff --git a/src/libraries/System.Net.WebHeaderCollection/src/System/Net/HeaderInfoTable.cs b/src/libraries/System.Net.WebHeaderCollection/src/System/Net/HeaderInfoTable.cs
@@ -35,10 +35,10 @@ private static string[] ParseValueHelper(string value, bool isSetCookie)
                 }
                 else if ((value[i] == ',') && !inquote)
                 {
-                    string singleValue = value.SubstringTrim(startIndex, length);
+                    ReadOnlySpan<char> singleValue = value.AsSpan(startIndex, length).Trim();
                     if (!isSetCookie || !IsDuringExpiresAttributeParsing(singleValue))
                     {
-                        tempStringCollection.Add(singleValue);
+                        tempStringCollection.Add(singleValue.ToString());
                         startIndex = i + 1;
                         length = 0;
                         continue;
@@ -50,7 +50,7 @@ private static string[] ParseValueHelper(string value, bool isSetCookie)
             // Now add the last of the header values to the string table.
             if (startIndex < value.Length && length > 0)
             {
-                tempStringCollection.Add(value.SubstringTrim(startIndex, length));
+                tempStringCollection.Add(value.AsSpan(startIndex, length).Trim().ToString());
             }
 
             return tempStringCollection.ToArray();
@@ -60,18 +60,25 @@ private static string[] ParseValueHelper(string value, bool isSetCookie)
         // for Set-Cookie header. It needs to check two conditions: 1. If current attribute
         // is Expires. 2. Have we finished parsing it yet. Because the Expires attribute
         // will contain exactly one comma, no comma means we are still parsing it.
-        private static bool IsDuringExpiresAttributeParsing(string singleValue)
+        private static bool IsDuringExpiresAttributeParsing(ReadOnlySpan<char> singleValue)
         {
-            // Current cookie doesn't contain any attributes.
-            if (!singleValue.Contains(';')) return false;
-
-            string lastElement = singleValue.Split(';')[^1];
-            bool noComma = !lastElement.Contains(',');
+            int semiPos = singleValue.LastIndexOf(';');
+            if (semiPos >= 0)
+            {
+                ReadOnlySpan<char> lastElement = singleValue.Slice(semiPos + 1);
+                if (!lastElement.Contains(','))
+                {
+                    int equalsPos = lastElement.IndexOf('=');
+                    if (equalsPos < 0)
+                    {
+                        equalsPos = lastElement.Length;
+                    }
 
-            string lastAttribute = lastElement.Split('=')[0].Trim();
-            bool isExpires = string.Equals(lastAttribute, "Expires", StringComparison.OrdinalIgnoreCase);
+                    return lastElement.Slice(0, equalsPos).Trim().Equals("Expires", StringComparison.OrdinalIgnoreCase);
+                }
+            }
 
-            return (isExpires && noComma);
+            return false;
         }
 
         private static Hashtable CreateHeaderHashtable()

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@`
`31`	`31`	`// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`
`32`	`32`	`//`
`33`	`33`
	`34`	`+using System.Buffers;`
`34`	`35`	`using System.Collections.Specialized;`
`35`	`36`	`using System.Diagnostics;`
`36`	`37`	`using System.Globalization;`
`@@ -63,8 +64,8 @@ private sealed class Context : TransportContext`
`63`	`64`	`private Stream? _inputStream;`
`64`	`65`	`private HttpListenerContext _context;`
`65`	`66`	`private bool _isChunked;`
`66`		`-`
`67`		`- private static byte[] s_100continue = "HTTP/1.1 100 Continue\r\n\r\n"u8.ToArray();`
	`67`	+ private static readonly IndexOfAnyValues<char> s_validMethodChars = IndexOfAnyValues.Create("!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz\|~");
	`68`	`+ private static readonly byte[] s_100continue = "HTTP/1.1 100 Continue\r\n\r\n"u8.ToArray();`
`68`	`69`
`69`	`70`	`internal HttpListenerRequest(HttpListenerContext context)`
`70`	`71`	`{`
`@@ -75,37 +76,32 @@ internal HttpListenerRequest(HttpListenerContext context)`
`75`	`76`
`76`	`77`	`internal void SetRequestLine(string req)`
`77`	`78`	`{`
`78`		`- string[] parts = req.Split(' ', 3);`
`79`		`- if (parts.Length != 3)`
	`79`	`+ Span<Range> parts = stackalloc Range[3];`
	`80`	`+ if (req.AsSpan().Split(parts, ' ') != 3)`
`80`	`81`	`{`
`81`	`82`	`_context.ErrorMessage = "Invalid request line (parts).";`
`82`	`83`	`return;`
`83`	`84`	`}`
`84`	`85`
`85`		`- _method = parts[0];`
`86`		`- foreach (char c in _method)`
	`86`	`+ _method = req[parts[0]];`
	`87`	`+ if (_method.AsSpan().IndexOfAnyExcept(s_validMethodChars) >= 0)`
`87`	`88`	`{`
`88`		`- if (char.IsAsciiLetterUpper(c) \|\|`
`89`		`- (c > 32 && c < 127 && c != '(' && c != ')' && c != '<' &&`
`90`		`- c != '<' && c != '>' && c != '@' && c != ',' && c != ';' &&`
`91`		`- c != ':' && c != '\\' && c != '"' && c != '/' && c != '[' &&`
`92`		`- c != ']' && c != '?' && c != '=' && c != '{' && c != '}'))`
`93`		`- continue;`
`94`		`-`
`95`	`89`	`_context.ErrorMessage = "(Invalid verb)";`
`96`	`90`	`return;`
`97`	`91`	`}`
`98`	`92`
`99`		`- _rawUrl = parts[1];`
`100`		`- if (parts[2].Length != 8 \|\| !parts[2].StartsWith("HTTP/", StringComparison.Ordinal))`
	`93`	`+ _rawUrl = req[parts[1]];`
	`94`	`+`
	`95`	`+ ReadOnlySpan<char> version = req.AsSpan()[parts[2]];`
	`96`	`+ if (version.Length != 8 \|\| !version.StartsWith("HTTP/", StringComparison.Ordinal))`
`101`	`97`	`{`
`102`	`98`	`_context.ErrorMessage = "Invalid request line (version).";`
`103`	`99`	`return;`
`104`	`100`	`}`
`105`	`101`
`106`	`102`	`try`
`107`	`103`	`{`
`108`		`- _version = new Version(parts[2].Substring(5));`
	`104`	`+ _version = Version.Parse(version.Slice("HTTP/".Length));`
`109`	`105`	`}`
`110`	`106`	`catch`
`111`	`107`	`{`
`@@ -231,15 +227,6 @@ internal void FinishInitialization()`
`231`	`227`	`}`
`232`	`228`	`}`
`233`	`229`
`234`		`- internal static string Unquote(string str)`
`235`		`- {`
`236`		`- int start = str.IndexOf('\"');`
`237`		`- int end = str.LastIndexOf('\"');`
`238`		`- if (start >= 0 && end >= 0)`
`239`		`- str = str.Substring(start + 1, end - 1);`
`240`		`- return str.Trim();`
`241`		`- }`
`242`		`-`
`243`	`230`	`internal void AddHeader(string header)`
`244`	`231`	`{`
`245`	`232`	`int colon = header.IndexOf(':');`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ internal static int ParseDefaultTtlFromFile(string filePath)`
`101`	`101`	`internal static int ParseRawIntFile(string filePath)`
`102`	`102`	`{`
`103`	`103`	`int ret;`
`104`		`- if (!int.TryParse(ReadAllText(filePath).Trim(), out ret))`
	`104`	`+ if (!int.TryParse(ReadAllText(filePath).AsSpan().Trim(), out ret))`
`105`	`105`	`{`
`106`	`106`	`throw ExceptionHelper.CreateForParseFailure();`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -272,7 +272,7 @@ public string? CharacterSet`
`272`	`272`	`string srchString = contentType.ToLowerInvariant();`
`273`	`273`
`274`	`274`	`//media subtypes of text type has a default as specified by rfc 2616`
`275`		`- if (srchString.Trim().StartsWith("text/", StringComparison.Ordinal))`
	`275`	`+ if (srchString.AsSpan().Trim().StartsWith("text/", StringComparison.Ordinal))`
`276`	`276`	`{`
`277`	`277`	`_characterSet = "ISO-8859-1";`
`278`	`278`	`}`