TryParse< TEnum >() [3/6]

static bool System.Enum.TryParse< TEnum > ( ReadOnlySpan< char > value, bool ignoreCase, bool throwOnFailure, out TEnum result )

inlinestaticprivate

Type Constraints

TEnum

:

struct

Definition at line 556 of file Enum.cs.

                                                                                                                                      : struct
    {
        if (!typeof(TEnum).IsEnum)
        {
            throw new ArgumentException(SR.Arg_MustBeEnum, "TEnum");
        }
        value = value.TrimStart();
        if (value.Length == 0)
        {
            if (throwOnFailure)
            {
                throw new ArgumentException(SR.Arg_MustContainEnumInfo, "value");
            }
            result = default(TEnum);
            return false;
        }
        RuntimeType enumType = (RuntimeType)typeof(TEnum);
        int result3;
        uint result6;
        switch (Type.GetTypeCode(typeof(TEnum)))
        {
        case TypeCode.SByte:
        {
            bool flag = TryParseInt32Enum(enumType, value, -128, 127, ignoreCase, throwOnFailure, TypeCode.SByte, out result3);
            sbyte source2 = (sbyte)result3;
            result = Unsafe.As<sbyte, TEnum>(ref source2);
            return flag;
        }
        case TypeCode.Int16:
        {
            bool flag = TryParseInt32Enum(enumType, value, -32768, 32767, ignoreCase, throwOnFailure, TypeCode.Int16, out result3);
            short source = (short)result3;
            result = Unsafe.As<short, TEnum>(ref source);
            return flag;
        }
        case TypeCode.Int32:
        {
            bool flag = TryParseInt32Enum(enumType, value, int.MinValue, int.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int32, out result3);
            result = Unsafe.As<int, TEnum>(ref result3);
            return flag;
        }
        case TypeCode.Byte:
        {
            bool flag = TryParseUInt32Enum(enumType, value, 255u, ignoreCase, throwOnFailure, TypeCode.Byte, out result6);
            byte source4 = (byte)result6;
            result = Unsafe.As<byte, TEnum>(ref source4);
            return flag;
        }
        case TypeCode.UInt16:
        {
            bool flag = TryParseUInt32Enum(enumType, value, 65535u, ignoreCase, throwOnFailure, TypeCode.UInt16, out result6);
            ushort source3 = (ushort)result6;
            result = Unsafe.As<ushort, TEnum>(ref source3);
            return flag;
        }
        case TypeCode.UInt32:
        {
            bool flag = TryParseUInt32Enum(enumType, value, uint.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt32, out result6);
            result = Unsafe.As<uint, TEnum>(ref result6);
            return flag;
        }
        case TypeCode.Int64:
        {
            long result5;
            bool flag = TryParseInt64Enum(enumType, value, ignoreCase, throwOnFailure, out result5);
            result = Unsafe.As<long, TEnum>(ref result5);
            return flag;
        }
        case TypeCode.UInt64:
        {
            ulong result4;
            bool flag = TryParseUInt64Enum(enumType, value, ignoreCase, throwOnFailure, out result4);
            result = Unsafe.As<ulong, TEnum>(ref result4);
            return flag;
        }
        default:
        {
            object result2;
            bool flag = TryParseRareEnum(enumType, value, ignoreCase, throwOnFailure, out result2);
            result = (flag ? ((TEnum)result2) : default(TEnum));
            return flag;
        }
        }
    }

References System.SR.Arg_MustBeEnum, System.SR.Arg_MustContainEnumInfo, System.Type.GetTypeCode(), System.Reflection.MaxValue, System.source, System.Enum.TryParseInt32Enum(), System.Enum.TryParseInt64Enum(), System.Enum.TryParseRareEnum(), System.Enum.TryParseUInt32Enum(), System.Enum.TryParseUInt64Enum(), and System.value.