Remove most of string.Trim() usages in System.Private.Xml solution. (#75452)

* Remove most of string.Trim() usages in Xml solution.

* Address feedback

* Add checks if input string is null

Co-authored-by: Traian Zaprianov <Traian.Zaprianov@docuware.com>

8 files changed, 149 insertions, 144 deletions

diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
index dfc7c93ce69..02db7686b08 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
@@ -5119,7 +5119,7 @@ namespace System.Xml
                         PushXmlContext();
                     }
 
-                    switch (XmlConvert.TrimString(attr.StringValue))
+                    switch (attr.StringValue.AsSpan().Trim(XmlConvert.WhitespaceChars))
                     {
                         case "preserve":
                             _xmlContext.xmlSpace = XmlSpace.Preserve;
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextWriter.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextWriter.cs
index d593a97e7d5..f0cd667e171 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextWriter.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextWriter.cs
@@ -1758,18 +1758,16 @@ namespace System.Xml
                     break;
                 case SpecialAttr.XmlSpace:
                     // validate XmlSpace attribute
-                    value = XmlConvert.TrimString(value);
-                    if (value == "default")
+                    switch (value.AsSpan().Trim(XmlConvert.WhitespaceChars))
                     {
-                        _stack[_top].xmlSpace = XmlSpace.Default;
-                    }
-                    else if (value == "preserve")
-                    {
-                        _stack[_top].xmlSpace = XmlSpace.Preserve;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(SR.Format(SR.Xml_InvalidXmlSpace, value));
+                        case "default":
+                            _stack[_top].xmlSpace = XmlSpace.Default;
+                            break;
+                        case "preserve":
+                            _stack[_top].xmlSpace = XmlSpace.Preserve;
+                            break;
+                        default:
+                            throw new ArgumentException(SR.Format(SR.Xml_InvalidXmlSpace, value));
                     }
                     break;
                 case SpecialAttr.XmlNs:
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlWellFormedWriterHelpers.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlWellFormedWriterHelpers.cs
index e905d9663c3..9652a0b3489 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlWellFormedWriterHelpers.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlWellFormedWriterHelpers.cs
@@ -403,10 +403,11 @@ namespace System.Xml
 
                 // trim the string in StringBuilder
                 string valBefore = _stringValue.ToString();
-                string valAfter = XmlConvert.TrimString(valBefore);
+                ReadOnlySpan<char> valAfter = valBefore.AsSpan().Trim(XmlConvert.WhitespaceChars);
                 if (valBefore != valAfter)
                 {
-                    _stringValue = new StringBuilder(valAfter);
+                    _stringValue = new StringBuilder();
+                    _stringValue.Append(valAfter);
                 }
 
                 // trim the beginning of the recorded writer events
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs b/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
index d0dda8c64c5..32e77bc9cff 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
@@ -1349,7 +1349,7 @@ namespace System.Xml
                     elem = node as XmlElement;
                     if (elem != null && elem.HasAttribute("xml:space"))
                     {
-                        switch (XmlConvert.TrimString(elem.GetAttribute("xml:space")))
+                        switch (elem.GetAttribute("xml:space").AsSpan().Trim(XmlConvert.WhitespaceChars))
                         {
                             case "default":
                                 return XmlSpace.Default;
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Schema/XmlValueConverter.cs b/src/libraries/System.Private.Xml/src/System/Xml/Schema/XmlValueConverter.cs
index 7fc4393af3d..a52eb320166 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Schema/XmlValueConverter.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Schema/XmlValueConverter.cs
@@ -588,7 +588,7 @@ namespace System.Xml.Schema
         {
             try
             {
-                return XmlConvert.FromBinHexString(XmlConvert.TrimString(value), false);
+                return XmlConvert.FromBinHexString(value.AsSpan().Trim(XmlConvert.WhitespaceChars), false);
             }
             catch (XmlException e)
             {
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Serialization/Xmlcustomformatter.cs b/src/libraries/System.Private.Xml/src/System/Xml/Serialization/Xmlcustomformatter.cs
index 385d54e3181..2338d8d46e9 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Serialization/Xmlcustomformatter.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Serialization/Xmlcustomformatter.cs
@@ -437,8 +437,7 @@ namespace System.Xml.Serialization
         internal static byte[]? ToByteArrayHex(string? value)
         {
             if (value == null) return null;
-            value = value.Trim();
-            return XmlConvert.FromBinHexString(value);
+            return XmlConvert.FromBinHexString(value.AsSpan().Trim(), true);
         }
 
         internal static long ToEnum(string val, Hashtable vals, string? typeName, bool validate)
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/XPath/XPathNavigatorReader.cs b/src/libraries/System.Private.Xml/src/System/Xml/XPath/XPathNavigatorReader.cs
index 3f07b88a265..2d721747ace 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/XPath/XPathNavigatorReader.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/XPath/XPathNavigatorReader.cs
@@ -264,7 +264,7 @@ namespace System.Xml.XPath
                 {
                     if (tempNav.MoveToAttribute(XPathNavigatorReader.space, XmlReservedNs.NsXml))
                     {
-                        switch (XmlConvert.TrimString(tempNav.Value))
+                        switch (tempNav.Value.AsSpan().Trim(XmlConvert.WhitespaceChars))
                         {
                             case "default":
                                 return XmlSpace.Default;
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/XmlConvert.cs b/src/libraries/System.Private.Xml/src/System/Xml/XmlConvert.cs
index c5935daf6ae..760d2a6c2ef 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/XmlConvert.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/XmlConvert.cs
@@ -291,16 +291,9 @@ namespace System.Xml
             return HexConverter.FromChar(digit);
         }
 
-        internal static byte[] FromBinHexString(string s)
+        internal static byte[] FromBinHexString(ReadOnlySpan<char> s, bool allowOddCount)
         {
-            return FromBinHexString(s, true);
-        }
-
-        internal static byte[] FromBinHexString(string s, bool allowOddCount)
-        {
-            ArgumentNullException.ThrowIfNull(s);
-
-            return BinHexDecoder.Decode(s.AsSpan(), allowOddCount);
+            return BinHexDecoder.Decode(s, allowOddCount);
         }
 
         internal static string ToBinHexString(byte[] inArray)
@@ -761,28 +754,35 @@ namespace System.Xml
 
         public static bool ToBoolean(string s)
         {
-            s = TrimString(s);
-            if (s == "1" || s == "true") return true;
-            if (s == "0" || s == "false") return false;
-            throw new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Boolean"));
+            switch (s.AsSpan().Trim(WhitespaceChars))
+            {
+                case "1":
+                case "true":
+                    return true;
+                case "0":
+                case "false":
+                    return false;
+                default:
+                    throw new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Boolean"));
+            }
         }
 
         internal static Exception? TryToBoolean(string s, out bool result)
         {
-            s = TrimString(s);
-            if (s == "0" || s == "false")
-            {
-                result = false;
-                return null;
-            }
-            else if (s == "1" || s == "true")
+            switch (s.AsSpan().Trim(WhitespaceChars))
             {
-                result = true;
-                return null;
+                case "0":
+                case "false":
+                    result = false;
+                    return null;
+                case "1":
+                case "true":
+                    result = true;
+                    return null;
+                default:
+                    result = false;
+                    return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Boolean"));
             }
-
-            result = false;
-            return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Boolean"));
         }
 
         public static char ToChar(string s)
@@ -963,143 +963,150 @@ namespace System.Xml
 
         public static float ToSingle(string s)
         {
-            s = TrimString(s);
-            if (s == "-INF") return float.NegativeInfinity;
-            if (s == "INF") return float.PositiveInfinity;
-            float f = float.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo);
-            if (f == 0 && s[0] == '-')
+            ArgumentNullException.ThrowIfNull(s);
+
+            ReadOnlySpan<char> value = s.AsSpan().Trim(WhitespaceChars);
+            switch (value)
             {
-                return -0f;
-            }
+                case "-INF":
+                    return float.NegativeInfinity;
+                case "INF":
+                    return float.PositiveInfinity;
+                default:
+                    float f = float.Parse(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo);
+                    if (f == 0 && value[0] == '-')
+                    {
+                        return -0f;
+                    }
 
-            return f;
+                    return f;
+            }
         }
 
         internal static Exception? TryToSingle(string s, out float result)
         {
-            s = TrimString(s);
-            if (s == "-INF")
-            {
-                result = float.NegativeInfinity;
-                return null;
-            }
-            else if (s == "INF")
+            ReadOnlySpan<char> value = s.AsSpan().Trim(WhitespaceChars);
+            switch (value)
             {
-                result = float.PositiveInfinity;
-                return null;
-            }
-            else if (!float.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result))
-            {
-                return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Single"));
-            }
+                case "-INF":
+                    result = float.NegativeInfinity;
+                    return null;
+                case "INF":
+                    result = float.PositiveInfinity;
+                    return null;
+                default:
+                    if (!float.TryParse(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result))
+                    {
+                        return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Single"));
+                    }
+                    if (result == 0 && value[0] == '-')
+                    {
+                        result = -0f;
+                    }
 
-            if (result == 0 && s[0] == '-')
-            {
-                result = -0f;
+                    return null;
             }
-
-            return null;
         }
 
         public static double ToDouble(string s)
         {
-            s = TrimString(s);
-            if (s == "-INF") return double.NegativeInfinity;
-            if (s == "INF") return double.PositiveInfinity;
+            ArgumentNullException.ThrowIfNull(s);
 
-            double dVal = double.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
-            if (dVal == 0 && s[0] == '-')
+            ReadOnlySpan<char> value = s.AsSpan().Trim(WhitespaceChars);
+            switch (value)
             {
-                return -0d;
-            }
+                case "-INF":
+                    return double.NegativeInfinity;
+                case "INF":
+                    return double.PositiveInfinity;
+                default:
+                    double dVal = double.Parse(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
+                    if (dVal == 0 && value[0] == '-')
+                    {
+                        return -0d;
+                    }
 
-            return dVal;
+                    return dVal;
+            }
         }
 
         internal static Exception? TryToDouble(string s, out double result)
         {
-            s = TrimString(s);
-            if (s == "-INF")
-            {
-                result = double.NegativeInfinity;
-                return null;
-            }
-            else if (s == "INF")
-            {
-                result = double.PositiveInfinity;
-                return null;
-            }
-            else if (!double.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result))
+            ReadOnlySpan<char> value = s.AsSpan().Trim(WhitespaceChars);
+            switch (value)
             {
-                return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Double"));
-            }
+                case "-INF":
+                    result = double.NegativeInfinity;
+                    return null;
+                case "INF":
+                    result = double.PositiveInfinity;
+                    return null;
+                default:
+                    if (!double.TryParse(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result))
+                    {
+                        return new FormatException(SR.Format(SR.XmlConvert_BadFormat, s, "Double"));
+                    }
 
-            if (result == 0 && s[0] == '-')
-            {
-                result = -0d;
-            }
+                    if (result == 0 && value[0] == '-')
+                    {
+                        result = -0d;
+                    }
 
-            return null;
+                    return null;
+            }
         }
 
         internal static double ToXPathDouble(object? o)
         {
-            if (o is string str)
+            switch (o)
             {
-                str = TrimString(str);
-                if (str.Length != 0 && str[0] != '+')
-                {
-                    double d;
-                    if (double.TryParse(str, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out d))
+                case string str:
                     {
-                        return d;
-                    }
-                }
-                return double.NaN;
-            }
-
-            if (o is double oDouble)
-            {
-                return oDouble;
-            }
+                        ArgumentNullException.ThrowIfNull(str);
 
-            if (o is bool oBool)
-            {
-                return oBool ? 1.0 : 0.0;
-            }
+                        ReadOnlySpan<char> value = str.AsSpan().Trim(WhitespaceChars);
+                        if (value.Length != 0 && value[0] != '+')
+                        {
+                            if (double.TryParse(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out double d))
+                            {
+                                return d;
+                            }
+                        }
+                        return double.NaN;
+                    }
+                case double oDouble:
+                    return oDouble;
+                case bool oBool:
+                    return oBool ? 1.0 : 0.0;
+                default:
+                    try
+                    {
+                        return Convert.ToDouble(o, NumberFormatInfo.InvariantInfo);
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+                    catch (ArgumentNullException) { }
 
-            try
-            {
-                return Convert.ToDouble(o, NumberFormatInfo.InvariantInfo);
-            }
-            catch (FormatException)
-            {
+                    return double.NaN;
             }
-            catch (OverflowException)
-            {
-            }
-            catch (ArgumentNullException) { }
-
-            return double.NaN;
         }
 
         internal static string? ToXPathString(object? value)
         {
-            if (value is string s)
+            switch (value)
             {
-                return s;
-            }
-            else if (value is double)
-            {
-                return ((double)value).ToString("R", NumberFormatInfo.InvariantInfo);
-            }
-            else if (value is bool)
-            {
-                return (bool)value ? "true" : "false";
-            }
-            else
-            {
-                return Convert.ToString(value, NumberFormatInfo.InvariantInfo);
+                case string s:
+                    return s;
+                case double d:
+                    return d.ToString("R", NumberFormatInfo.InvariantInfo);
+                case bool b:
+                    return b ? "true" : "false";
+                default:
+                    return Convert.ToString(value, NumberFormatInfo.InvariantInfo);
             }
         }