System.Net.Http: String.Compare -> String.Equals

Per the Best Practices for Using Strings at
http://msdn.microsoft.com/en-us/library/dd465121(v=vs.110).aspx

* Use an overload of the String.Equals method to test whether two
strings are equal.
* Use the String.Compare and String.CompareTo methods to sort strings,
not to check for equality.

Also, replaced String.ToLowerInvariant().GetHashCode() with
StringComparer.OrdinalIgnoreCase.GetHashCode().

Author: justinvp

src/System.Net.Http/src/System/Net/Headers/AuthenticationHeaderValue.cs

@@ -74,19 +74,19 @@ public override bool Equals(object obj)
 
             if (string.IsNullOrEmpty(_parameter) && string.IsNullOrEmpty(other._parameter))
             {
-                return (string.Compare(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase) == 0);
+                return (string.Equals(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase));
             }
             else
             {
                 // Since we can't parse the parameter, we use case-sensitive comparison.
-                return (string.Compare(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase) == 0) &&
-                    (string.CompareOrdinal(_parameter, other._parameter) == 0);
+                return string.Equals(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase) &&
+                    string.Equals(_parameter, other._parameter, StringComparison.Ordinal);
             }
         }
 
         public override int GetHashCode()
         {
-            int result = _scheme.ToLowerInvariant().GetHashCode();
+            int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_scheme);
 
             if (!string.IsNullOrEmpty(_parameter))
             {

src/System.Net.Http/src/System/Net/Headers/CacheControlHeaderValue.cs

@@ -333,15 +333,15 @@ public override int GetHashCode()
             {
                 foreach (var noCacheHeader in _noCacheHeaders)
                 {
-                    result = result ^ noCacheHeader.ToLowerInvariant().GetHashCode();
+                    result = result ^ StringComparer.OrdinalIgnoreCase.GetHashCode(noCacheHeader);
                 }
             }
 
             if ((_privateHeaders != null) && (_privateHeaders.Count > 0))
             {
                 foreach (var privateHeader in _privateHeaders)
                 {
-                    result = result ^ privateHeader.ToLowerInvariant().GetHashCode();
+                    result = result ^ StringComparer.OrdinalIgnoreCase.GetHashCode(privateHeader);
                 }
             }
 

src/System.Net.Http/src/System/Net/Headers/ContentDispositionHeaderValue.cs

@@ -178,14 +178,14 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return (string.Compare(_dispositionType, other._dispositionType, StringComparison.OrdinalIgnoreCase) == 0) &&
+            return string.Equals(_dispositionType, other._dispositionType, StringComparison.OrdinalIgnoreCase) &&
                 HeaderUtilities.AreEqualCollections(_parameters, other._parameters);
         }
 
         public override int GetHashCode()
         {
             // The dispositionType string is case-insensitive.
-            return _dispositionType.ToLowerInvariant().GetHashCode() ^ NameValueHeaderValue.GetHashCode(_parameters);
+            return StringComparer.OrdinalIgnoreCase.GetHashCode(_dispositionType) ^ NameValueHeaderValue.GetHashCode(_parameters);
         }
 
         // Implement ICloneable explicitly to allow derived types to "override" the implementation.

src/System.Net.Http/src/System/Net/Headers/ContentRangeHeaderValue.cs

@@ -127,12 +127,12 @@ public override bool Equals(object obj)
             }
 
             return ((_from == other._from) && (_to == other._to) && (_length == other._length) &&
-                (string.Compare(_unit, other._unit, StringComparison.OrdinalIgnoreCase) == 0));
+                string.Equals(_unit, other._unit, StringComparison.OrdinalIgnoreCase));
         }
 
         public override int GetHashCode()
         {
-            int result = _unit.ToLowerInvariant().GetHashCode();
+            int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_unit);
 
             if (HasRange)
             {

src/System.Net.Http/src/System/Net/Headers/EntityTagHeaderValue.cs

@@ -92,7 +92,7 @@ public override bool Equals(object obj)
             }
 
             // Since the tag is a quoted-string we treat it case-sensitive.
-            return ((_isWeak == other._isWeak) && (string.CompareOrdinal(_tag, other._tag) == 0));
+            return ((_isWeak == other._isWeak) && string.Equals(_tag, other._tag, StringComparison.Ordinal));
         }
 
         public override int GetHashCode()

src/System.Net.Http/src/System/Net/Headers/MediaTypeHeaderValue.cs

@@ -113,14 +113,14 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return (string.Compare(_mediaType, other._mediaType, StringComparison.OrdinalIgnoreCase) == 0) &&
+            return string.Equals(_mediaType, other._mediaType, StringComparison.OrdinalIgnoreCase) &&
                 HeaderUtilities.AreEqualCollections(_parameters, other._parameters);
         }
 
         public override int GetHashCode()
         {
             // The media-type string is case-insensitive.
-            return _mediaType.ToLowerInvariant().GetHashCode() ^ NameValueHeaderValue.GetHashCode(_parameters);
+            return StringComparer.OrdinalIgnoreCase.GetHashCode(_mediaType) ^ NameValueHeaderValue.GetHashCode(_parameters);
         }
 
         public static MediaTypeHeaderValue Parse(string input)

src/System.Net.Http/src/System/Net/Headers/NameValueHeaderValue.cs

@@ -62,7 +62,7 @@ public override int GetHashCode()
         {
             Debug.Assert(_name != null);
 
-            int nameHashCode = _name.ToLowerInvariant().GetHashCode();
+            int nameHashCode = StringComparer.OrdinalIgnoreCase.GetHashCode(_name);
 
             if (!string.IsNullOrEmpty(_value))
             {
@@ -73,7 +73,7 @@ public override int GetHashCode()
                     return nameHashCode ^ _value.GetHashCode();
                 }
 
-                return nameHashCode ^ _value.ToLowerInvariant().GetHashCode();
+                return nameHashCode ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_value);
             }
 
             return nameHashCode;
@@ -88,7 +88,7 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            if (string.Compare(_name, other._name, StringComparison.OrdinalIgnoreCase) != 0)
+            if (!string.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase))
             {
                 return false;
             }
@@ -105,11 +105,11 @@ public override bool Equals(object obj)
             if (_value[0] == '"')
             {
                 // We have a quoted string, so we need to do case-sensitive comparison.
-                return (string.CompareOrdinal(_value, other._value) == 0);
+                return string.Equals(_value, other._value, StringComparison.Ordinal);
             }
             else
             {
-                return (string.Compare(_value, other._value, StringComparison.OrdinalIgnoreCase) == 0);
+                return string.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase);
             }
         }
 
@@ -307,7 +307,7 @@ internal static NameValueHeaderValue Find(ICollection<NameValueHeaderValue> valu
 
             foreach (var value in values)
             {
-                if (string.Compare(value.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
+                if (string.Equals(value.Name, name, StringComparison.OrdinalIgnoreCase))
                 {
                     return value;
                 }

src/System.Net.Http/src/System/Net/Headers/ProductHeaderValue.cs

@@ -69,17 +69,17 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return (string.Compare(_name, other._name, StringComparison.OrdinalIgnoreCase) == 0) &&
-                (string.Compare(_version, other._version, StringComparison.OrdinalIgnoreCase) == 0);
+            return string.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase) &&
+                string.Equals(_version, other._version, StringComparison.OrdinalIgnoreCase);
         }
 
         public override int GetHashCode()
         {
-            int result = _name.ToLowerInvariant().GetHashCode();
+            int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_name);
 
             if (!string.IsNullOrEmpty(_version))
             {
-                result = result ^ _version.ToLowerInvariant().GetHashCode();
+                result = result ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_version);
             }
 
             return result;

src/System.Net.Http/src/System/Net/Headers/ProductInfoHeaderValue.cs

@@ -74,7 +74,7 @@ public override bool Equals(object obj)
             if (_product == null)
             {
                 // We compare comments using case-sensitive comparison.
-                return string.CompareOrdinal(_comment, other._comment) == 0;
+                return string.Equals(_comment, other._comment, StringComparison.Ordinal);
             }
 
             return _product.Equals(other._product);

src/System.Net.Http/src/System/Net/Headers/RangeHeaderValue.cs

@@ -95,13 +95,13 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return (string.Compare(_unit, other._unit, StringComparison.OrdinalIgnoreCase) == 0) &&
+            return string.Equals(_unit, other._unit, StringComparison.OrdinalIgnoreCase) &&
                 HeaderUtilities.AreEqualCollections(Ranges, other.Ranges);
         }
 
         public override int GetHashCode()
         {
-            int result = _unit.ToLowerInvariant().GetHashCode();
+            int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_unit);
 
             foreach (RangeItemHeaderValue range in Ranges)
             {