netcore/System.Private.CoreLib/shared/System/Enum.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.Diagnostics;
   6 using System.Diagnostics.CodeAnalysis;
   7 using System.Globalization;
   8 using System.Reflection;
   9 using System.Runtime.CompilerServices;
  10 using Internal.Runtime.CompilerServices;
  11
  12 #if CORERT
  13 using CorElementType = System.Runtime.RuntimeImports.RhCorElementType;
  14 using RuntimeType = System.Type;
  15 using EnumInfo = Internal.Runtime.Augments.EnumInfo;
  16 #endif
  17
  18 // The code below includes partial support for float/double and
  19 // pointer sized enums.
  20 //
  21 // The type loader does not prohibit such enums, and older versions of
  22 // the ECMA spec include them as possible enum types.
  23 //
  24 // However there are many things broken throughout the stack for
  25 // float/double/intptr/uintptr enums. There was a conscious decision
  26 // made to not fix the whole stack to work well for them because of
  27 // the right behavior is often unclear, and it is hard to test and
  28 // very low value because of such enums cannot be expressed in C#.
  29
  30 namespace System
  31 {
  32     [Serializable]
  33     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  34     public abstract partial class Enum : ValueType, IComparable, IFormattable, IConvertible
  35     {
  36         #region Private Constants
  37         private const char EnumSeparatorChar = ',';
  38         #endregion
  39
  40         #region Private Static Methods
  41
  42         private string ValueToString()
  43         {
  44             ref byte data = ref this.GetRawData();
  45             return (InternalGetCorElementType()) switch
  46             {
  47                 CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref data).ToString(),
  48                 CorElementType.ELEMENT_TYPE_U1 => data.ToString(),
  49                 CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref data).ToString(),
  50                 CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref data).ToString(),
  51                 CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref data).ToString(),
  52                 CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref data).ToString(),
  53                 CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref data).ToString(),
  54                 CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref data).ToString(),
  55                 CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref data).ToString(),
  56                 CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref data).ToString(),
  57                 CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref data).ToString(),
  58                 CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref data).ToString(),
  59                 CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref data).ToString(),
  60                 CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref data).ToString(),
  61                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
  62             };
  63         }
  64
  65         private string ValueToHexString()
  66         {
  67             ref byte data = ref this.GetRawData();
  68             switch (InternalGetCorElementType())
  69             {
  70                 case CorElementType.ELEMENT_TYPE_I1:
  71                 case CorElementType.ELEMENT_TYPE_U1:
  72                     return data.ToString("X2", null);
  73                 case CorElementType.ELEMENT_TYPE_BOOLEAN:
  74                     return Convert.ToByte(Unsafe.As<byte, bool>(ref data)).ToString("X2", null);
  75                 case CorElementType.ELEMENT_TYPE_I2:
  76                 case CorElementType.ELEMENT_TYPE_U2:
  77                 case CorElementType.ELEMENT_TYPE_CHAR:
  78                     return Unsafe.As<byte, ushort>(ref data).ToString("X4", null);
  79                 case CorElementType.ELEMENT_TYPE_I4:
  80                 case CorElementType.ELEMENT_TYPE_U4:
  81                     return Unsafe.As<byte, uint>(ref data).ToString("X8", null);
  82                 case CorElementType.ELEMENT_TYPE_I8:
  83                 case CorElementType.ELEMENT_TYPE_U8:
  84                     return Unsafe.As<byte, ulong>(ref data).ToString("X16", null);
  85                 default:
  86                     throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
  87             }
  88         }
  89
  90         private static string ValueToHexString(object value)
  91         {
  92             return (Convert.GetTypeCode(value)) switch
  93             {
  94                 TypeCode.SByte => ((byte)(sbyte)value).ToString("X2", null),
  95                 TypeCode.Byte => ((byte)value).ToString("X2", null),
  96                 TypeCode.Boolean => Convert.ToByte((bool)value).ToString("X2", null), // direct cast from bool to byte is not allowed
  97                 TypeCode.Int16 => ((ushort)(short)value).ToString("X4", null),
  98                 TypeCode.UInt16 => ((ushort)value).ToString("X4", null),
  99                 TypeCode.Char => ((ushort)(char)value).ToString("X4", null),
 100                 TypeCode.UInt32 => ((uint)value).ToString("X8", null),
 101                 TypeCode.Int32 => ((uint)(int)value).ToString("X8", null),
 102                 TypeCode.UInt64 => ((ulong)value).ToString("X16", null),
 103                 TypeCode.Int64 => ((ulong)(long)value).ToString("X16", null),
 104                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
 105             };
 106         }
 107
 108         internal static string? GetEnumName(RuntimeType enumType, ulong ulValue)
 109         {
 110             return GetEnumName(GetEnumInfo(enumType), ulValue);
 111         }
 112
 113         private static string? GetEnumName(EnumInfo enumInfo, ulong ulValue)
 114         {
 115             int index = Array.BinarySearch(enumInfo.Values, ulValue);
 116             if (index >= 0)
 117             {
 118                 return enumInfo.Names[index];
 119             }
 120
 121             return null; // return null so the caller knows to .ToString() the input
 122         }
 123
 124         private static string? InternalFormat(RuntimeType enumType, ulong value)
 125         {
 126             EnumInfo enumInfo = GetEnumInfo(enumType);
 127
 128             if (!enumInfo.HasFlagsAttribute)
 129             {
 130                 return GetEnumName(enumInfo, value);
 131             }
 132             else // These are flags OR'ed together (We treat everything as unsigned types)
 133             {
 134                 return InternalFlagsFormat(enumType, enumInfo, value);
 135             }
 136         }
 137
 138         private static string? InternalFlagsFormat(RuntimeType enumType, ulong result)
 139         {
 140             return InternalFlagsFormat(enumType, GetEnumInfo(enumType), result);
 141         }
 142
 143         private static string? InternalFlagsFormat(RuntimeType enumType, EnumInfo enumInfo, ulong resultValue)
 144         {
 145             Debug.Assert(enumType != null);
 146
 147             string[] names = enumInfo.Names;
 148             ulong[] values = enumInfo.Values;
 149             Debug.Assert(names.Length == values.Length);
 150
 151             // Values are sorted, so if the incoming value is 0, we can check to see whether
 152             // the first entry matches it, in which case we can return its name; otherwise,
 153             // we can just return "0".
 154             if (resultValue == 0)
 155             {
 156                 return values.Length > 0 && values[0] == 0 ?
 157                     names[0] :
 158                     "0";
 159             }
 160
 161             // With a ulong result value, regardless of the enum's base type, the maximum
 162             // possible number of consistent name/values we could have is 64, since every
 163             // value is made up of one or more bits, and when we see values and incorporate
 164             // their names, we effectively switch off those bits.
 165             Span<int> foundItems = stackalloc int[64];
 166
 167             // Walk from largest to smallest. It's common to have a flags enum with a single
 168             // value that matches a single entry, in which case we can just return the existing
 169             // name string.
 170             int index = values.Length - 1;
 171             while (index >= 0)
 172             {
 173                 if (values[index] == resultValue)
 174                 {
 175                     return names[index];
 176                 }
 177
 178                 if (values[index] < resultValue)
 179                 {
 180                     break;
 181                 }
 182
 183                 index--;
 184             }
 185
 186             // Now look for multiple matches, storing the indices of the values
 187             // into our span.
 188             int resultLength = 0, foundItemsCount = 0;
 189             while (index >= 0)
 190             {
 191                 ulong currentValue = values[index];
 192                 if (index == 0 && currentValue == 0)
 193                 {
 194                     break;
 195                 }
 196
 197                 if ((resultValue & currentValue) == currentValue)
 198                 {
 199                     resultValue -= currentValue;
 200                     foundItems[foundItemsCount++] = index;
 201                     resultLength = checked(resultLength + names[index].Length);
 202                 }
 203
 204                 index--;
 205             }
 206
 207             // If we exhausted looking through all the values and we still have
 208             // a non-zero result, we couldn't match the result to only named values.
 209             // In that case, we return null and let the call site just generate
 210             // a string for the integral value.
 211             if (resultValue != 0)
 212             {
 213                 return null;
 214             }
 215
 216             // We know what strings to concatenate.  Do so.
 217
 218             Debug.Assert(foundItemsCount > 0);
 219             const int SeparatorStringLength = 2; // ", "
 220             string result = string.FastAllocateString(checked(resultLength + (SeparatorStringLength * (foundItemsCount - 1))));
 221
 222             Span<char> resultSpan = new Span<char>(ref result.GetRawStringData(), result.Length);
 223             string name = names[foundItems[--foundItemsCount]];
 224             name.AsSpan().CopyTo(resultSpan);
 225             resultSpan = resultSpan.Slice(name.Length);
 226             while (--foundItemsCount >= 0)
 227             {
 228                 resultSpan[0] = EnumSeparatorChar;
 229                 resultSpan[1] = ' ';
 230                 resultSpan = resultSpan.Slice(2);
 231
 232                 name = names[foundItems[foundItemsCount]];
 233                 name.AsSpan().CopyTo(resultSpan);
 234                 resultSpan = resultSpan.Slice(name.Length);
 235             }
 236             Debug.Assert(resultSpan.IsEmpty);
 237
 238             return result;
 239         }
 240
 241         internal static ulong ToUInt64(object value)
 242         {
 243             // Helper function to silently convert the value to UInt64 from the other base types for enum without throwing an exception.
 244             // This is need since the Convert functions do overflow checks.
 245             TypeCode typeCode = Convert.GetTypeCode(value);
 246             ulong result = typeCode switch
 247             {
 248                 TypeCode.SByte => (ulong)(sbyte)value,
 249                 TypeCode.Byte => (byte)value,
 250                 TypeCode.Boolean => Convert.ToByte((bool)value), // direct cast from bool to byte is not allowed
 251                 TypeCode.Int16 => (ulong)(short)value,
 252                 TypeCode.UInt16 => (ushort)value,
 253                 TypeCode.Char => (ushort)(char)value,
 254                 TypeCode.UInt32 => (uint)value,
 255                 TypeCode.Int32 => (ulong)(int)value,
 256                 TypeCode.UInt64 => (ulong)value,
 257                 TypeCode.Int64 => (ulong)(long)value,
 258                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
 259             };
 260             return result;
 261         }
 262
 263         #endregion
 264
 265         #region Public Static Methods
 266         public static object Parse(Type enumType, string value) =>
 267             Parse(enumType, value, ignoreCase: false);
 268
 269         public static object Parse(Type enumType, string value, bool ignoreCase)
 270         {
 271             bool success = TryParse(enumType, value, ignoreCase, throwOnFailure: true, out object? result);
 272             Debug.Assert(success);
 273             return result!;
 274         }
 275
 276         public static TEnum Parse<TEnum>(string value) where TEnum : struct =>
 277             Parse<TEnum>(value, ignoreCase: false);
 278
 279         public static TEnum Parse<TEnum>(string value, bool ignoreCase) where TEnum : struct
 280         {
 281             bool success = TryParse<TEnum>(value, ignoreCase, throwOnFailure: true, out TEnum result);
 282             Debug.Assert(success);
 283             return result;
 284         }
 285
 286         public static bool TryParse(Type enumType, string? value, out object? result) =>
 287             TryParse(enumType, value, ignoreCase: false, out result);
 288
 289         public static bool TryParse(Type enumType, string? value, bool ignoreCase, out object? result) =>
 290             TryParse(enumType, value, ignoreCase, throwOnFailure: false, out result);
 291
 292         private static bool TryParse(Type enumType, string? value, bool ignoreCase, bool throwOnFailure, out object? result)
 293         {
 294             // Validation on the enum type itself.  Failures here are considered non-parsing failures
 295             // and thus always throw rather than returning false.
 296             RuntimeType rt = ValidateRuntimeType(enumType);
 297
 298             ReadOnlySpan<char> valueSpan = value.AsSpan().TrimStart();
 299             if (valueSpan.Length == 0)
 300             {
 301                 if (throwOnFailure)
 302                 {
 303                     throw value == null ?
 304                         new ArgumentNullException(nameof(value)) :
 305                         new ArgumentException(SR.Arg_MustContainEnumInfo, nameof(value));
 306                 }
 307                 result = null;
 308                 return false;
 309             }
 310
 311             int intResult;
 312             uint uintResult;
 313             bool parsed;
 314
 315             switch (Type.GetTypeCode(rt))
 316             {
 317                 case TypeCode.SByte:
 318                     parsed = TryParseInt32Enum(rt, value, valueSpan, sbyte.MinValue, sbyte.MaxValue, ignoreCase, throwOnFailure, TypeCode.SByte, out intResult);
 319                     result = parsed ? InternalBoxEnum(rt, intResult) : null;
 320                     return parsed;
 321
 322                 case TypeCode.Int16:
 323                     parsed = TryParseInt32Enum(rt, value, valueSpan, short.MinValue, short.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int16, out intResult);
 324                     result = parsed ? InternalBoxEnum(rt, intResult) : null;
 325                     return parsed;
 326
 327                 case TypeCode.Int32:
 328                     parsed = TryParseInt32Enum(rt, value, valueSpan, int.MinValue, int.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int32, out intResult);
 329                     result = parsed ? InternalBoxEnum(rt, intResult) : null;
 330                     return parsed;
 331
 332                 case TypeCode.Byte:
 333                     parsed = TryParseUInt32Enum(rt, value, valueSpan, byte.MaxValue, ignoreCase, throwOnFailure, TypeCode.Byte, out uintResult);
 334                     result = parsed ? InternalBoxEnum(rt, uintResult) : null;
 335                     return parsed;
 336
 337                 case TypeCode.UInt16:
 338                     parsed = TryParseUInt32Enum(rt, value, valueSpan, ushort.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt16, out uintResult);
 339                     result = parsed ? InternalBoxEnum(rt, uintResult) : null;
 340                     return parsed;
 341
 342                 case TypeCode.UInt32:
 343                     parsed = TryParseUInt32Enum(rt, value, valueSpan, uint.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt32, out uintResult);
 344                     result = parsed ? InternalBoxEnum(rt, uintResult) : null;
 345                     return parsed;
 346
 347                 case TypeCode.Int64:
 348                     parsed = TryParseInt64Enum(rt, value, valueSpan, ignoreCase, throwOnFailure, out long longResult);
 349                     result = parsed ? InternalBoxEnum(rt, longResult) : null;
 350                     return parsed;
 351
 352                 case TypeCode.UInt64:
 353                     parsed = TryParseUInt64Enum(rt, value, valueSpan, ignoreCase, throwOnFailure, out ulong ulongResult);
 354                     result = parsed ? InternalBoxEnum(rt, (long)ulongResult) : null;
 355                     return parsed;
 356
 357                 default:
 358                     return TryParseRareEnum(rt, value, valueSpan, ignoreCase, throwOnFailure, out result);
 359             }
 360         }
 361
 362         public static bool TryParse<TEnum>(string? value, out TEnum result) where TEnum : struct =>
 363             TryParse<TEnum>(value, ignoreCase: false, out result);
 364
 365         public static bool TryParse<TEnum>(string? value, bool ignoreCase, out TEnum result) where TEnum : struct =>
 366             TryParse<TEnum>(value, ignoreCase, throwOnFailure: false, out result);
 367
 368         private static bool TryParse<TEnum>(string? value, bool ignoreCase, bool throwOnFailure, out TEnum result) where TEnum : struct
 369         {
 370             // Validation on the enum type itself.  Failures here are considered non-parsing failures
 371             // and thus always throw rather than returning false.
 372             if (!typeof(TEnum).IsEnum)
 373             {
 374                 throw new ArgumentException(SR.Arg_MustBeEnum, nameof(TEnum));
 375             }
 376
 377             ReadOnlySpan<char> valueSpan = value.AsSpan().TrimStart();
 378             if (valueSpan.Length == 0)
 379             {
 380                 if (throwOnFailure)
 381                 {
 382                     throw value == null ?
 383                         new ArgumentNullException(nameof(value)) :
 384                         new ArgumentException(SR.Arg_MustContainEnumInfo, nameof(value));
 385                 }
 386                 result = default;
 387                 return false;
 388             }
 389
 390             int intResult;
 391             uint uintResult;
 392             bool parsed;
 393             RuntimeType rt = (RuntimeType)typeof(TEnum);
 394
 395             switch (Type.GetTypeCode(typeof(TEnum)))
 396             {
 397                 case TypeCode.SByte:
 398                     parsed = TryParseInt32Enum(rt, value, valueSpan, sbyte.MinValue, sbyte.MaxValue, ignoreCase, throwOnFailure, TypeCode.SByte, out intResult);
 399                     sbyte sbyteResult = (sbyte)intResult;
 400                     result = Unsafe.As<sbyte, TEnum>(ref sbyteResult);
 401                     return parsed;
 402
 403                 case TypeCode.Int16:
 404                     parsed = TryParseInt32Enum(rt, value, valueSpan, short.MinValue, short.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int16, out intResult);
 405                     short shortResult = (short)intResult;
 406                     result = Unsafe.As<short, TEnum>(ref shortResult);
 407                     return parsed;
 408
 409                 case TypeCode.Int32:
 410                     parsed = TryParseInt32Enum(rt, value, valueSpan, int.MinValue, int.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int32, out intResult);
 411                     result = Unsafe.As<int, TEnum>(ref intResult);
 412                     return parsed;
 413
 414                 case TypeCode.Byte:
 415                     parsed = TryParseUInt32Enum(rt, value, valueSpan, byte.MaxValue, ignoreCase, throwOnFailure, TypeCode.Byte, out uintResult);
 416                     byte byteResult = (byte)uintResult;
 417                     result = Unsafe.As<byte, TEnum>(ref byteResult);
 418                     return parsed;
 419
 420                 case TypeCode.UInt16:
 421                     parsed = TryParseUInt32Enum(rt, value, valueSpan, ushort.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt16, out uintResult);
 422                     ushort ushortResult = (ushort)uintResult;
 423                     result = Unsafe.As<ushort, TEnum>(ref ushortResult);
 424                     return parsed;
 425
 426                 case TypeCode.UInt32:
 427                     parsed = TryParseUInt32Enum(rt, value, valueSpan, uint.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt32, out uintResult);
 428                     result = Unsafe.As<uint, TEnum>(ref uintResult);
 429                     return parsed;
 430
 431                 case TypeCode.Int64:
 432                     parsed = TryParseInt64Enum(rt, value, valueSpan, ignoreCase, throwOnFailure, out long longResult);
 433                     result = Unsafe.As<long, TEnum>(ref longResult);
 434                     return parsed;
 435
 436                 case TypeCode.UInt64:
 437                     parsed = TryParseUInt64Enum(rt, value, valueSpan, ignoreCase, throwOnFailure, out ulong ulongResult);
 438                     result = Unsafe.As<ulong, TEnum>(ref ulongResult);
 439                     return parsed;
 440
 441                 default:
 442                     parsed = TryParseRareEnum(rt, value, valueSpan, ignoreCase, throwOnFailure, out object? objectResult);
 443                     result = parsed ? (TEnum)objectResult! : default;
 444                     return parsed;
 445             }
 446         }
 447
 448         /// <summary>Tries to parse the value of an enum with known underlying types that fit in an Int32 (Int32, Int16, and SByte).</summary>
 449         private static bool TryParseInt32Enum(
 450             RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, int minInclusive, int maxInclusive, bool ignoreCase, bool throwOnFailure, TypeCode type, out int result)
 451         {
 452             Debug.Assert(
 453                 enumType.GetEnumUnderlyingType() == typeof(sbyte) ||
 454                 enumType.GetEnumUnderlyingType() == typeof(short) ||
 455                 enumType.GetEnumUnderlyingType() == typeof(int));
 456
 457             Number.ParsingStatus status = default;
 458             if (StartsNumber(value[0]))
 459             {
 460                 status = Number.TryParseInt32IntegerStyle(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture.NumberFormat, out result);
 461                 if (status == Number.ParsingStatus.OK)
 462                 {
 463                     if ((uint)(result - minInclusive) <= (uint)(maxInclusive - minInclusive))
 464                     {
 465                         return true;
 466                     }
 467
 468                     status = Number.ParsingStatus.Overflow;
 469                 }
 470             }
 471
 472             if (status == Number.ParsingStatus.Overflow)
 473             {
 474                 if (throwOnFailure)
 475                 {
 476                     Number.ThrowOverflowException(type);
 477                 }
 478             }
 479             else if (TryParseByName(enumType, originalValueString, value, ignoreCase, throwOnFailure, out ulong ulongResult))
 480             {
 481                 result = (int)ulongResult;
 482                 Debug.Assert(result >= minInclusive && result <= maxInclusive);
 483                 return true;
 484             }
 485
 486             result = 0;
 487             return false;
 488         }
 489
 490         /// <summary>Tries to parse the value of an enum with known underlying types that fit in a UInt32 (UInt32, UInt16, and Byte).</summary>
 491         private static bool TryParseUInt32Enum(RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, uint maxInclusive, bool ignoreCase, bool throwOnFailure, TypeCode type, out uint result)
 492         {
 493             Debug.Assert(
 494                 enumType.GetEnumUnderlyingType() == typeof(byte) ||
 495                 enumType.GetEnumUnderlyingType() == typeof(ushort) ||
 496                 enumType.GetEnumUnderlyingType() == typeof(uint));
 497
 498             Number.ParsingStatus status = default;
 499             if (StartsNumber(value[0]))
 500             {
 501                 status = Number.TryParseUInt32IntegerStyle(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture.NumberFormat, out result);
 502                 if (status == Number.ParsingStatus.OK)
 503                 {
 504                     if (result <= maxInclusive)
 505                     {
 506                         return true;
 507                     }
 508
 509                     status = Number.ParsingStatus.Overflow;
 510                 }
 511             }
 512
 513             if (status == Number.ParsingStatus.Overflow)
 514             {
 515                 if (throwOnFailure)
 516                 {
 517                     Number.ThrowOverflowException(type);
 518                 }
 519             }
 520             else if (TryParseByName(enumType, originalValueString, value, ignoreCase, throwOnFailure, out ulong ulongResult))
 521             {
 522                 result = (uint)ulongResult;
 523                 Debug.Assert(result <= maxInclusive);
 524                 return true;
 525             }
 526
 527             result = 0;
 528             return false;
 529         }
 530
 531         /// <summary>Tries to parse the value of an enum with Int64 as the underlying type.</summary>
 532         private static bool TryParseInt64Enum(RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out long result)
 533         {
 534             Debug.Assert(enumType.GetEnumUnderlyingType() == typeof(long));
 535
 536             Number.ParsingStatus status = default;
 537             if (StartsNumber(value[0]))
 538             {
 539                 status = Number.TryParseInt64IntegerStyle(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture.NumberFormat, out result);
 540                 if (status == Number.ParsingStatus.OK)
 541                 {
 542                     return true;
 543                 }
 544             }
 545
 546             if (status == Number.ParsingStatus.Overflow)
 547             {
 548                 if (throwOnFailure)
 549                 {
 550                     Number.ThrowOverflowException(TypeCode.Int64);
 551                 }
 552             }
 553             else if (TryParseByName(enumType, originalValueString, value, ignoreCase, throwOnFailure, out ulong ulongResult))
 554             {
 555                 result = (long)ulongResult;
 556                 return true;
 557             }
 558
 559             result = 0;
 560             return false;
 561         }
 562
 563         /// <summary>Tries to parse the value of an enum with UInt64 as the underlying type.</summary>
 564         private static bool TryParseUInt64Enum(RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out ulong result)
 565         {
 566             Debug.Assert(enumType.GetEnumUnderlyingType() == typeof(ulong));
 567
 568             Number.ParsingStatus status = default;
 569             if (StartsNumber(value[0]))
 570             {
 571                 status = Number.TryParseUInt64IntegerStyle(value, NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture.NumberFormat, out result);
 572                 if (status == Number.ParsingStatus.OK)
 573                 {
 574                     return true;
 575                 }
 576             }
 577
 578             if (status == Number.ParsingStatus.Overflow)
 579             {
 580                 if (throwOnFailure)
 581                 {
 582                     Number.ThrowOverflowException(TypeCode.UInt64);
 583                 }
 584             }
 585             else if (TryParseByName(enumType, originalValueString, value, ignoreCase, throwOnFailure, out result))
 586             {
 587                 return true;
 588             }
 589
 590             result = 0;
 591             return false;
 592         }
 593
 594         /// <summary>Tries to parse the value of an enum with an underlying type that can't be expressed in C# (e.g. char, bool, double, etc.)</summary>
 595         private static bool TryParseRareEnum(RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, [NotNullWhen(true)] out object? result)
 596         {
 597             Debug.Assert(
 598                 enumType.GetEnumUnderlyingType() != typeof(sbyte) &&
 599                 enumType.GetEnumUnderlyingType() != typeof(byte) &&
 600                 enumType.GetEnumUnderlyingType() != typeof(short) &&
 601                 enumType.GetEnumUnderlyingType() != typeof(ushort) &&
 602                 enumType.GetEnumUnderlyingType() != typeof(int) &&
 603                 enumType.GetEnumUnderlyingType() != typeof(uint) &&
 604                 enumType.GetEnumUnderlyingType() != typeof(long) &&
 605                 enumType.GetEnumUnderlyingType() != typeof(ulong),
 606                 "Should only be used when parsing enums with rare underlying types, those that can't be expressed in C#.");
 607
 608             if (StartsNumber(value[0]))
 609             {
 610                 Type underlyingType = GetUnderlyingType(enumType);
 611                 try
 612                 {
 613                     result = ToObject(enumType, Convert.ChangeType(value.ToString(), underlyingType, CultureInfo.InvariantCulture)!);
 614                     return true;
 615                 }
 616                 catch (FormatException)
 617                 {
 618                     // We need to Parse this as a String instead. There are cases
 619                     // when you tlbimp enums that can have values of the form "3D".
 620                 }
 621                 catch when (!throwOnFailure)
 622                 {
 623                     result = null;
 624                     return false;
 625                 }
 626             }
 627
 628             if (TryParseByName(enumType, originalValueString, value, ignoreCase, throwOnFailure, out ulong ulongResult))
 629             {
 630                 try
 631                 {
 632                     result = ToObject(enumType, ulongResult);
 633                     return true;
 634                 }
 635                 catch when (!throwOnFailure) { }
 636             }
 637
 638             result = null;
 639             return false;
 640         }
 641
 642         private static bool TryParseByName(RuntimeType enumType, string? originalValueString, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out ulong result)
 643         {
 644             // Find the field. Let's assume that these are always static classes because the class is an enum.
 645             EnumInfo enumInfo = GetEnumInfo(enumType);
 646             string[] enumNames = enumInfo.Names;
 647             ulong[] enumValues = enumInfo.Values;
 648
 649             bool parsed = true;
 650             ulong localResult = 0;
 651             while (value.Length > 0)
 652             {
 653                 // Find the next separator.
 654                 ReadOnlySpan<char> subvalue;
 655                 int endIndex = value.IndexOf(EnumSeparatorChar);
 656                 if (endIndex == -1)
 657                 {
 658                     // No next separator; use the remainder as the next value.
 659                     subvalue = value.Trim();
 660                     value = default;
 661                 }
 662                 else if (endIndex != value.Length - 1)
 663                 {
 664                     // Found a separator before the last char.
 665                     subvalue = value.Slice(0, endIndex).Trim();
 666                     value = value.Slice(endIndex + 1);
 667                 }
 668                 else
 669                 {
 670                     // Last char was a separator, which is invalid.
 671                     parsed = false;
 672                     break;
 673                 }
 674
 675                 // Try to match this substring against each enum name
 676                 bool success = false;
 677                 if (ignoreCase)
 678                 {
 679                     for (int i = 0; i < enumNames.Length; i++)
 680                     {
 681                         if (subvalue.EqualsOrdinalIgnoreCase(enumNames[i]))
 682                         {
 683                             localResult |= enumValues[i];
 684                             success = true;
 685                             break;
 686                         }
 687                     }
 688                 }
 689                 else
 690                 {
 691                     for (int i = 0; i < enumNames.Length; i++)
 692                     {
 693                         if (subvalue.EqualsOrdinal(enumNames[i]))
 694                         {
 695                             localResult |= enumValues[i];
 696                             success = true;
 697                             break;
 698                         }
 699                     }
 700                 }
 701
 702                 if (!success)
 703                 {
 704                     parsed = false;
 705                     break;
 706                 }
 707             }
 708
 709             if (parsed)
 710             {
 711                 result = localResult;
 712                 return true;
 713             }
 714
 715             if (throwOnFailure)
 716             {
 717                 throw new ArgumentException(SR.Format(SR.Arg_EnumValueNotFound, originalValueString));
 718             }
 719
 720             result = 0;
 721             return false;
 722         }
 723
 724         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 725         private static bool StartsNumber(char c) => char.IsInRange(c, '0', '9') || c == '-' || c == '+';
 726
 727         public static object ToObject(Type enumType, object value)
 728         {
 729             if (value == null)
 730                 throw new ArgumentNullException(nameof(value));
 731
 732             // Delegate rest of error checking to the other functions
 733             TypeCode typeCode = Convert.GetTypeCode(value);
 734
 735             return typeCode switch
 736             {
 737                 TypeCode.Int32 => ToObject(enumType, (int)value),
 738                 TypeCode.SByte => ToObject(enumType, (sbyte)value),
 739                 TypeCode.Int16 => ToObject(enumType, (short)value),
 740                 TypeCode.Int64 => ToObject(enumType, (long)value),
 741                 TypeCode.UInt32 => ToObject(enumType, (uint)value),
 742                 TypeCode.Byte => ToObject(enumType, (byte)value),
 743                 TypeCode.UInt16 => ToObject(enumType, (ushort)value),
 744                 TypeCode.UInt64 => ToObject(enumType, (ulong)value),
 745                 TypeCode.Char => ToObject(enumType, (char)value),
 746                 TypeCode.Boolean => ToObject(enumType, (bool)value),
 747                 _ => throw new ArgumentException(SR.Arg_MustBeEnumBaseTypeOrEnum, nameof(value)),
 748             };
 749         }
 750
 751         public static string Format(Type enumType, object value, string format)
 752         {
 753             RuntimeType rtType = ValidateRuntimeType(enumType);
 754
 755             if (value == null)
 756                 throw new ArgumentNullException(nameof(value));
 757
 758             if (format == null)
 759                 throw new ArgumentNullException(nameof(format));
 760
 761             // If the value is an Enum then we need to extract the underlying value from it
 762             Type valueType = value.GetType();
 763             if (valueType.IsEnum)
 764             {
 765                 if (!valueType.IsEquivalentTo(enumType))
 766                     throw new ArgumentException(SR.Format(SR.Arg_EnumAndObjectMustBeSameType, valueType, enumType));
 767
 768                 if (format.Length != 1)
 769                 {
 770                     // all acceptable format string are of length 1
 771                     throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
 772                 }
 773                 return ((Enum)value).ToString(format);
 774             }
 775
 776             // The value must be of the same type as the Underlying type of the Enum
 777             Type underlyingType = GetUnderlyingType(enumType);
 778             if (valueType != underlyingType)
 779             {
 780                 throw new ArgumentException(SR.Format(SR.Arg_EnumFormatUnderlyingTypeAndObjectMustBeSameType, valueType, underlyingType));
 781             }
 782
 783             if (format.Length == 1)
 784             {
 785                 switch (format[0])
 786                 {
 787                     case 'G':
 788                     case 'g':
 789                         return GetEnumName(rtType, ToUInt64(value)) ?? value.ToString()!;
 790
 791                     case 'D':
 792                     case 'd':
 793                         return value.ToString()!;
 794
 795                     case 'X':
 796                     case 'x':
 797                         return ValueToHexString(value);
 798
 799                     case 'F':
 800                     case 'f':
 801                         return InternalFlagsFormat(rtType, ToUInt64(value)) ?? value.ToString()!;
 802                 }
 803             }
 804
 805             throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
 806         }
 807         #endregion
 808
 809         #region Private Methods
 810         internal object GetValue()
 811         {
 812             ref byte data = ref this.GetRawData();
 813             return (InternalGetCorElementType()) switch
 814             {
 815                 CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref data),
 816                 CorElementType.ELEMENT_TYPE_U1 => data,
 817                 CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref data),
 818                 CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref data),
 819                 CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref data),
 820                 CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref data),
 821                 CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref data),
 822                 CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref data),
 823                 CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref data),
 824                 CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref data),
 825                 CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref data),
 826                 CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref data),
 827                 CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref data),
 828                 CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref data),
 829                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
 830             };
 831         }
 832
 833         private ulong ToUInt64()
 834         {
 835             ref byte data = ref this.GetRawData();
 836             switch (InternalGetCorElementType())
 837             {
 838                 case CorElementType.ELEMENT_TYPE_I1:
 839                     return (ulong)Unsafe.As<byte, sbyte>(ref data);
 840                 case CorElementType.ELEMENT_TYPE_U1:
 841                     return data;
 842                 case CorElementType.ELEMENT_TYPE_BOOLEAN:
 843                     return Convert.ToUInt64(Unsafe.As<byte, bool>(ref data), CultureInfo.InvariantCulture);
 844                 case CorElementType.ELEMENT_TYPE_I2:
 845                     return (ulong)Unsafe.As<byte, short>(ref data);
 846                 case CorElementType.ELEMENT_TYPE_U2:
 847                 case CorElementType.ELEMENT_TYPE_CHAR:
 848                     return Unsafe.As<byte, ushort>(ref data);
 849                 case CorElementType.ELEMENT_TYPE_I4:
 850                     return (ulong)Unsafe.As<byte, int>(ref data);
 851                 case CorElementType.ELEMENT_TYPE_U4:
 852                 case CorElementType.ELEMENT_TYPE_R4:
 853                     return Unsafe.As<byte, uint>(ref data);
 854                 case CorElementType.ELEMENT_TYPE_I8:
 855                     return (ulong)Unsafe.As<byte, long>(ref data);
 856                 case CorElementType.ELEMENT_TYPE_U8:
 857                 case CorElementType.ELEMENT_TYPE_R8:
 858                     return Unsafe.As<byte, ulong>(ref data);
 859                 case CorElementType.ELEMENT_TYPE_I:
 860                     return (ulong)Unsafe.As<byte, IntPtr>(ref data);
 861                 case CorElementType.ELEMENT_TYPE_U:
 862                     return (ulong)Unsafe.As<byte, UIntPtr>(ref data);
 863                 default:
 864                     throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
 865             }
 866         }
 867
 868         #endregion
 869
 870         #region Object Overrides
 871
 872         public override int GetHashCode()
 873         {
 874             // CONTRACT with the runtime: GetHashCode of enum types is implemented as GetHashCode of the underlying type.
 875             // The runtime can bypass calls to Enum::GetHashCode and call the underlying type's GetHashCode directly
 876             // to avoid boxing the enum.
 877             ref byte data = ref this.GetRawData();
 878             return (InternalGetCorElementType()) switch
 879             {
 880                 CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref data).GetHashCode(),
 881                 CorElementType.ELEMENT_TYPE_U1 => data.GetHashCode(),
 882                 CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref data).GetHashCode(),
 883                 CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref data).GetHashCode(),
 884                 CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref data).GetHashCode(),
 885                 CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref data).GetHashCode(),
 886                 CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref data).GetHashCode(),
 887                 CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref data).GetHashCode(),
 888                 CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref data).GetHashCode(),
 889                 CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref data).GetHashCode(),
 890                 CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref data).GetHashCode(),
 891                 CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref data).GetHashCode(),
 892                 CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref data).GetHashCode(),
 893                 CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref data).GetHashCode(),
 894                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
 895             };
 896         }
 897
 898         public override string ToString()
 899         {
 900             // Returns the value in a human readable format.  For PASCAL style enums who's value maps directly the name of the field is returned.
 901             // For PASCAL style enums who's values do not map directly the decimal value of the field is returned.
 902             // For BitFlags (indicated by the Flags custom attribute): If for each bit that is set in the value there is a corresponding constant
 903             // (a pure power of 2), then the OR string (ie "Red, Yellow") is returned. Otherwise, if the value is zero or if you can't create a string that consists of
 904             // pure powers of 2 OR-ed together, you return a hex value
 905
 906             // Try to see if its one of the enum values, then we return a String back else the value
 907             return InternalFormat((RuntimeType)GetType(), ToUInt64()) ?? ValueToString();
 908         }
 909         #endregion
 910
 911         #region IFormattable
 912         [Obsolete("The provider argument is not used. Please use ToString(String).")]
 913         public string ToString(string? format, IFormatProvider? provider)
 914         {
 915             return ToString(format);
 916         }
 917         #endregion
 918
 919         #region Public Methods
 920         public string ToString(string? format)
 921         {
 922             if (string.IsNullOrEmpty(format))
 923             {
 924                 return ToString();
 925             }
 926
 927             if (format.Length == 1)
 928             {
 929                 switch (format[0])
 930                 {
 931                     case 'G':
 932                     case 'g':
 933                         return ToString();
 934
 935                     case 'D':
 936                     case 'd':
 937                         return ValueToString();
 938
 939                     case 'X':
 940                     case 'x':
 941                         return ValueToHexString();
 942
 943                     case 'F':
 944                     case 'f':
 945                         return InternalFlagsFormat((RuntimeType)GetType(), ToUInt64()) ?? ValueToString();
 946                 }
 947             }
 948
 949             throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
 950         }
 951
 952         [Obsolete("The provider argument is not used. Please use ToString().")]
 953         public string ToString(IFormatProvider? provider)
 954         {
 955             return ToString();
 956         }
 957
 958         #endregion
 959
 960         #region IConvertible
 961         public TypeCode GetTypeCode()
 962         {
 963             return (InternalGetCorElementType()) switch
 964             {
 965                 CorElementType.ELEMENT_TYPE_I1 => TypeCode.SByte,
 966                 CorElementType.ELEMENT_TYPE_U1 => TypeCode.Byte,
 967                 CorElementType.ELEMENT_TYPE_BOOLEAN => TypeCode.Boolean,
 968                 CorElementType.ELEMENT_TYPE_I2 => TypeCode.Int16,
 969                 CorElementType.ELEMENT_TYPE_U2 => TypeCode.UInt16,
 970                 CorElementType.ELEMENT_TYPE_CHAR => TypeCode.Char,
 971                 CorElementType.ELEMENT_TYPE_I4 => TypeCode.Int32,
 972                 CorElementType.ELEMENT_TYPE_U4 => TypeCode.UInt32,
 973                 CorElementType.ELEMENT_TYPE_I8 => TypeCode.Int64,
 974                 CorElementType.ELEMENT_TYPE_U8 => TypeCode.UInt64,
 975                 _ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType),
 976             };
 977         }
 978
 979         bool IConvertible.ToBoolean(IFormatProvider? provider)
 980         {
 981             return Convert.ToBoolean(GetValue(), CultureInfo.CurrentCulture);
 982         }
 983
 984         char IConvertible.ToChar(IFormatProvider? provider)
 985         {
 986             return Convert.ToChar(GetValue(), CultureInfo.CurrentCulture);
 987         }
 988
 989         sbyte IConvertible.ToSByte(IFormatProvider? provider)
 990         {
 991             return Convert.ToSByte(GetValue(), CultureInfo.CurrentCulture);
 992         }
 993
 994         byte IConvertible.ToByte(IFormatProvider? provider)
 995         {
 996             return Convert.ToByte(GetValue(), CultureInfo.CurrentCulture);
 997         }
 998
 999         short IConvertible.ToInt16(IFormatProvider? provider)
1000         {
1001             return Convert.ToInt16(GetValue(), CultureInfo.CurrentCulture);
1002         }
1003
1004         ushort IConvertible.ToUInt16(IFormatProvider? provider)
1005         {
1006             return Convert.ToUInt16(GetValue(), CultureInfo.CurrentCulture);
1007         }
1008
1009         int IConvertible.ToInt32(IFormatProvider? provider)
1010         {
1011             return Convert.ToInt32(GetValue(), CultureInfo.CurrentCulture);
1012         }
1013
1014         uint IConvertible.ToUInt32(IFormatProvider? provider)
1015         {
1016             return Convert.ToUInt32(GetValue(), CultureInfo.CurrentCulture);
1017         }
1018
1019         long IConvertible.ToInt64(IFormatProvider? provider)
1020         {
1021             return Convert.ToInt64(GetValue(), CultureInfo.CurrentCulture);
1022         }
1023
1024         ulong IConvertible.ToUInt64(IFormatProvider? provider)
1025         {
1026             return Convert.ToUInt64(GetValue(), CultureInfo.CurrentCulture);
1027         }
1028
1029         float IConvertible.ToSingle(IFormatProvider? provider)
1030         {
1031             return Convert.ToSingle(GetValue(), CultureInfo.CurrentCulture);
1032         }
1033
1034         double IConvertible.ToDouble(IFormatProvider? provider)
1035         {
1036             return Convert.ToDouble(GetValue(), CultureInfo.CurrentCulture);
1037         }
1038
1039         decimal IConvertible.ToDecimal(IFormatProvider? provider)
1040         {
1041             return Convert.ToDecimal(GetValue(), CultureInfo.CurrentCulture);
1042         }
1043
1044         DateTime IConvertible.ToDateTime(IFormatProvider? provider)
1045         {
1046             throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Enum", "DateTime"));
1047         }
1048
1049         object IConvertible.ToType(Type type, IFormatProvider? provider)
1050         {
1051             return Convert.DefaultToType((IConvertible)this, type, provider);
1052         }
1053         #endregion
1054
1055         #region ToObject
1056         [CLSCompliant(false)]
1057         public static object ToObject(Type enumType, sbyte value) =>
1058             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1059
1060         public static object ToObject(Type enumType, short value) =>
1061             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1062
1063         public static object ToObject(Type enumType, int value) =>
1064             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1065
1066         public static object ToObject(Type enumType, byte value) =>
1067             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1068
1069         [CLSCompliant(false)]
1070         public static object ToObject(Type enumType, ushort value) =>
1071             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1072
1073         [CLSCompliant(false)]
1074         public static object ToObject(Type enumType, uint value) =>
1075             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1076
1077         public static object ToObject(Type enumType, long value) =>
1078             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1079
1080         [CLSCompliant(false)]
1081         public static object ToObject(Type enumType, ulong value) =>
1082             InternalBoxEnum(ValidateRuntimeType(enumType), unchecked((long)value));
1083
1084         private static object ToObject(Type enumType, char value) =>
1085             InternalBoxEnum(ValidateRuntimeType(enumType), value);
1086
1087         private static object ToObject(Type enumType, bool value) =>
1088             InternalBoxEnum(ValidateRuntimeType(enumType), value ? 1 : 0);
1089
1090         #endregion
1091     }
1092 }