netcore/System.Private.CoreLib/shared/System/StringComparer.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Collections;
   6 using System.Collections.Generic;
   7 using System.Globalization;
   8 using System.Runtime.Serialization;
   9
  10 namespace System
  11 {
  12     [Serializable]
  13     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  14     public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string?>, IEqualityComparer<string?>
  15     {
  16         private static readonly CultureAwareComparer s_invariantCulture = new CultureAwareComparer(CultureInfo.InvariantCulture, CompareOptions.None);
  17         private static readonly CultureAwareComparer s_invariantCultureIgnoreCase = new CultureAwareComparer(CultureInfo.InvariantCulture, CompareOptions.IgnoreCase);
  18         private static readonly OrdinalCaseSensitiveComparer s_ordinal = new OrdinalCaseSensitiveComparer();
  19         private static readonly OrdinalIgnoreCaseComparer s_ordinalIgnoreCase = new OrdinalIgnoreCaseComparer();
  20
  21         public static StringComparer InvariantCulture
  22         {
  23             get
  24             {
  25                 return s_invariantCulture;
  26             }
  27         }
  28
  29         public static StringComparer InvariantCultureIgnoreCase
  30         {
  31             get
  32             {
  33                 return s_invariantCultureIgnoreCase;
  34             }
  35         }
  36
  37         public static StringComparer CurrentCulture
  38         {
  39             get
  40             {
  41                 return new CultureAwareComparer(CultureInfo.CurrentCulture, CompareOptions.None);
  42             }
  43         }
  44
  45         public static StringComparer CurrentCultureIgnoreCase
  46         {
  47             get
  48             {
  49                 return new CultureAwareComparer(CultureInfo.CurrentCulture, CompareOptions.IgnoreCase);
  50             }
  51         }
  52
  53         public static StringComparer Ordinal
  54         {
  55             get
  56             {
  57                 return s_ordinal;
  58             }
  59         }
  60
  61         public static StringComparer OrdinalIgnoreCase
  62         {
  63             get
  64             {
  65                 return s_ordinalIgnoreCase;
  66             }
  67         }
  68
  69         // Convert a StringComparison to a StringComparer
  70         public static StringComparer FromComparison(StringComparison comparisonType)
  71         {
  72             switch (comparisonType)
  73             {
  74                 case StringComparison.CurrentCulture:
  75                     return CurrentCulture;
  76                 case StringComparison.CurrentCultureIgnoreCase:
  77                     return CurrentCultureIgnoreCase;
  78                 case StringComparison.InvariantCulture:
  79                     return InvariantCulture;
  80                 case StringComparison.InvariantCultureIgnoreCase:
  81                     return InvariantCultureIgnoreCase;
  82                 case StringComparison.Ordinal:
  83                     return Ordinal;
  84                 case StringComparison.OrdinalIgnoreCase:
  85                     return OrdinalIgnoreCase;
  86                 default:
  87                     throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
  88             }
  89         }
  90
  91         public static StringComparer Create(CultureInfo culture, bool ignoreCase)
  92         {
  93             if (culture == null)
  94             {
  95                 throw new ArgumentNullException(nameof(culture));
  96             }
  97
  98             return new CultureAwareComparer(culture, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
  99         }
 100
 101         public static StringComparer Create(CultureInfo culture, CompareOptions options)
 102         {
 103             if (culture == null)
 104             {
 105                 throw new ArgumentException(nameof(culture));
 106             }
 107
 108             return new CultureAwareComparer(culture, options);
 109         }
 110
 111         public int Compare(object? x, object? y)
 112         {
 113             if (x == y) return 0;
 114             if (x == null) return -1;
 115             if (y == null) return 1;
 116
 117             if (x is string sa)
 118             {
 119                 if (y is string sb)
 120                 {
 121                     return Compare(sa, sb);
 122                 }
 123             }
 124
 125             if (x is IComparable ia)
 126             {
 127                 return ia.CompareTo(y);
 128             }
 129
 130             throw new ArgumentException(SR.Argument_ImplementIComparable);
 131         }
 132
 133         public new bool Equals(object? x, object? y)
 134         {
 135             if (x == y) return true;
 136             if (x == null || y == null) return false;
 137
 138             if (x is string sa)
 139             {
 140                 if (y is string sb)
 141                 {
 142                     return Equals(sa, sb);
 143                 }
 144             }
 145             return x.Equals(y);
 146         }
 147
 148         public int GetHashCode(object obj)
 149         {
 150             if (obj == null)
 151             {
 152                 throw new ArgumentNullException(nameof(obj));
 153             }
 154
 155             if (obj is string s)
 156             {
 157                 return GetHashCode(s);
 158             }
 159             return obj.GetHashCode();
 160         }
 161
 162         public abstract int Compare(string? x, string? y);
 163         public abstract bool Equals(string? x, string? y);
 164 #pragma warning disable CS8614 // Remove warning disable when nullable attributes are respected
 165         public abstract int GetHashCode(string obj);
 166 #pragma warning restore CS8614
 167     }
 168
 169     [Serializable]
 170     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 171     public sealed class CultureAwareComparer : StringComparer, ISerializable
 172     {
 173         private const CompareOptions ValidCompareMaskOffFlags = ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth | CompareOptions.IgnoreKanaType | CompareOptions.StringSort);
 174
 175         private readonly CompareInfo _compareInfo; // Do not rename (binary serialization)
 176         private readonly CompareOptions _options;
 177
 178         internal CultureAwareComparer(CultureInfo culture, CompareOptions options) : this(culture.CompareInfo, options) { }
 179
 180         internal CultureAwareComparer(CompareInfo compareInfo, CompareOptions options)
 181         {
 182             _compareInfo = compareInfo;
 183
 184             if ((options & ValidCompareMaskOffFlags) != 0)
 185             {
 186                 throw new ArgumentException(SR.Argument_InvalidFlag, nameof(options));
 187             }
 188             _options = options;
 189         }
 190
 191         private CultureAwareComparer(SerializationInfo info, StreamingContext context)
 192         {
 193             _compareInfo = (CompareInfo)info.GetValue("_compareInfo", typeof(CompareInfo))!;
 194             bool ignoreCase = info.GetBoolean("_ignoreCase");
 195
 196             var obj = info.GetValueNoThrow("_options", typeof(CompareOptions));
 197             if (obj != null)
 198                 _options = (CompareOptions)obj;
 199
 200             // fix up the _options value in case we are getting old serialized object not having _options
 201             _options |= ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None;
 202         }
 203
 204         public override int Compare(string? x, string? y)
 205         {
 206             if (object.ReferenceEquals(x, y)) return 0;
 207             if (x == null) return -1;
 208             if (y == null) return 1;
 209             return _compareInfo.Compare(x, y, _options);
 210         }
 211
 212         public override bool Equals(string? x, string? y)
 213         {
 214             if (object.ReferenceEquals(x, y)) return true;
 215             if (x == null || y == null) return false;
 216             return _compareInfo.Compare(x, y, _options) == 0;
 217         }
 218
 219         public override int GetHashCode(string obj)
 220         {
 221             if (obj == null)
 222             {
 223                 throw new ArgumentNullException(nameof(obj));
 224             }
 225             return _compareInfo.GetHashCodeOfString(obj, _options);
 226         }
 227
 228         // Equals method for the comparer itself.
 229         public override bool Equals(object? obj)
 230         {
 231             return
 232                 obj is CultureAwareComparer comparer &&
 233                 _options == comparer._options &&
 234                 _compareInfo.Equals(comparer._compareInfo);
 235         }
 236
 237         public override int GetHashCode()
 238         {
 239             return _compareInfo.GetHashCode() ^ ((int)_options & 0x7FFFFFFF);
 240         }
 241
 242         public void GetObjectData(SerializationInfo info, StreamingContext context)
 243         {
 244             info.AddValue("_compareInfo", _compareInfo);
 245             info.AddValue("_options", _options);
 246             info.AddValue("_ignoreCase", (_options & CompareOptions.IgnoreCase) != 0);
 247         }
 248     }
 249
 250     [Serializable]
 251     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 252     public class OrdinalComparer : StringComparer
 253     {
 254         private readonly bool _ignoreCase; // Do not rename (binary serialization)
 255
 256         internal OrdinalComparer(bool ignoreCase)
 257         {
 258             _ignoreCase = ignoreCase;
 259         }
 260
 261         public override int Compare(string? x, string? y)
 262         {
 263             if (ReferenceEquals(x, y))
 264                 return 0;
 265             if (x == null)
 266                 return -1;
 267             if (y == null)
 268                 return 1;
 269
 270             if (_ignoreCase)
 271             {
 272                 return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
 273             }
 274
 275             return string.CompareOrdinal(x, y);
 276         }
 277
 278         public override bool Equals(string? x, string? y)
 279         {
 280             if (ReferenceEquals(x, y))
 281                 return true;
 282             if (x == null || y == null)
 283                 return false;
 284
 285             if (_ignoreCase)
 286             {
 287                 if (x.Length != y.Length)
 288                 {
 289                     return false;
 290                 }
 291                 return CompareInfo.EqualsOrdinalIgnoreCase(ref x.GetRawStringData(), ref y.GetRawStringData(), x.Length);
 292             }
 293             return x.Equals(y);
 294         }
 295
 296         public override int GetHashCode(string obj)
 297         {
 298             if (obj == null)
 299             {
 300                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
 301             }
 302
 303             if (_ignoreCase)
 304             {
 305                 return obj.GetHashCodeOrdinalIgnoreCase();
 306             }
 307
 308             return obj.GetHashCode();
 309         }
 310
 311         // Equals method for the comparer itself.
 312         public override bool Equals(object? obj)
 313         {
 314             if (!(obj is OrdinalComparer comparer))
 315             {
 316                 return false;
 317             }
 318             return (this._ignoreCase == comparer._ignoreCase);
 319         }
 320
 321         public override int GetHashCode()
 322         {
 323             int hashCode = nameof(OrdinalComparer).GetHashCode();
 324             return _ignoreCase ? (~hashCode) : hashCode;
 325         }
 326     }
 327
 328     [Serializable]
 329     internal sealed class OrdinalCaseSensitiveComparer : OrdinalComparer, ISerializable
 330     {
 331         public OrdinalCaseSensitiveComparer() : base(false)
 332         {
 333         }
 334
 335         public override int Compare(string? x, string? y) => string.CompareOrdinal(x, y);
 336
 337         public override bool Equals(string? x, string? y) => string.Equals(x, y);
 338
 339         public override int GetHashCode(string obj)
 340         {
 341             if (obj == null)
 342             {
 343                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
 344             }
 345             return obj.GetHashCode();
 346         }
 347
 348         public void GetObjectData(SerializationInfo info, StreamingContext context)
 349         {
 350             info.SetType(typeof(OrdinalComparer));
 351             info.AddValue("_ignoreCase", false);
 352         }
 353     }
 354
 355     [Serializable]
 356     internal sealed class OrdinalIgnoreCaseComparer : OrdinalComparer, ISerializable
 357     {
 358         public OrdinalIgnoreCaseComparer() : base(true)
 359         {
 360         }
 361
 362         public override int Compare(string? x, string? y) => string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
 363
 364         public override bool Equals(string? x, string? y)
 365         {
 366             if (ReferenceEquals(x, y))
 367             {
 368                 return true;
 369             }
 370
 371             if (x is null || y is null)
 372             {
 373                 return false;
 374             }
 375
 376             if (x.Length != y.Length)
 377             {
 378                 return false;
 379             }
 380
 381             return CompareInfo.EqualsOrdinalIgnoreCase(ref x.GetRawStringData(), ref y.GetRawStringData(), x.Length);
 382         }
 383
 384         public override int GetHashCode(string obj)
 385         {
 386             if (obj == null)
 387             {
 388                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
 389             }
 390             return obj.GetHashCodeOrdinalIgnoreCase();
 391         }
 392
 393         public void GetObjectData(SerializationInfo info, StreamingContext context)
 394         {
 395             info.SetType(typeof(OrdinalComparer));
 396             info.AddValue("_ignoreCase", true);
 397         }
 398     }
 399 }