c# - .NET 3.5 中 Enum.TryParse 的实现

Question

如何在 .NET 3.5 中实现 .NET 4 的 Enum.TryParse 方法？

public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct

Answer 1

我不喜欢使用 atry-catch来处理任何转换失败或其他非异常事件作为我的应用程序正常流程的一部分，因此我自己Enum.TryParse的 .NET 3.5 及更早版本使用该Enum.IsDefined()方法来确保不会出现异常由 Enum.Parse() 抛出。您还可以包括一些空检查value以防止ArgumentNullExceptionif 值为空。

public static bool TryParse<TEnum>(string value, out TEnum result)
    where TEnum : struct, IConvertible
{
    var retValue = value == null ? 
                false : 
                Enum.IsDefined(typeof(TEnum), value);
    result = retValue ?
                (TEnum)Enum.Parse(typeof(TEnum), value) :
                default(TEnum);
    return retValue;
}

显然，此方法不会驻留在Enum类中，因此您将需要一个适当的类来包含此方法。

一个限制是对泛型方法缺乏enum约束，因此您必须考虑如何处理不正确的类型。 Enum.IsDefined将抛出ArgumentExceptionif TEnumis not anenum但唯一的其他选项是运行时检查并抛出不同的异常，因此我通常不会添加额外的检查，只是让这些方法中的类型检查为我处理。我会考虑添加IConvertible另一个约束，只是为了帮助更多地约束类型。

Answer 2

花费的时间比我希望的要长，但它有效并且已经过测试。希望这可以节省一些时间！

    private static readonly char[] FlagDelimiter = new [] { ',' };

    public static bool TryParseEnum<TEnum>(string value, out TEnum result) where TEnum : struct {
        if (string.IsNullOrEmpty(value)) {
            result = default(TEnum);
            return false;
        }

        var enumType = typeof(TEnum);

        if (!enumType.IsEnum)
            throw new ArgumentException(string.Format("Type '{0}' is not an enum", enumType.FullName));


        result = default(TEnum);

        // Try to parse the value directly 
        if (Enum.IsDefined(enumType, value)) {
            result = (TEnum)Enum.Parse(enumType, value);
            return true;
        }

        // Get some info on enum
        var enumValues = Enum.GetValues(enumType);
        if (enumValues.Length == 0)
            return false;  // probably can't happen as you cant define empty enum?
        var enumTypeCode = Type.GetTypeCode(enumValues.GetValue(0).GetType());

        // Try to parse it as a flag 
        if (value.IndexOf(',') != -1) {
            if (!Attribute.IsDefined(enumType, typeof(FlagsAttribute)))
                return false;  // value has flags but enum is not flags

            // todo: cache this for efficiency
            var enumInfo = new Dictionary<string, object>();
            var enumNames = Enum.GetNames(enumType);
            for (var i = 0; i < enumNames.Length; i++)
                enumInfo.Add(enumNames[i], enumValues.GetValue(i));

            ulong retVal = 0;
            foreach(var name in value.Split(FlagDelimiter)) {
                var trimmedName = name.Trim();
                if (!enumInfo.ContainsKey(trimmedName))
                    return false;   // Enum has no such flag

                var enumValueObject = enumInfo[trimmedName];
                ulong enumValueLong;
                switch (enumTypeCode) {
                    case TypeCode.Byte:
                        enumValueLong = (byte)enumValueObject;
                        break;
                    case TypeCode.SByte:
                        enumValueLong = (byte)((sbyte)enumValueObject);
                        break;
                    case TypeCode.Int16:
                        enumValueLong = (ushort)((short)enumValueObject);
                        break;
                    case TypeCode.Int32:
                        enumValueLong = (uint)((int)enumValueObject);
                        break;
                    case TypeCode.Int64:
                        enumValueLong = (ulong)((long)enumValueObject);
                        break;
                    case TypeCode.UInt16:
                        enumValueLong = (ushort)enumValueObject;
                        break;
                    case TypeCode.UInt32:
                        enumValueLong = (uint)enumValueObject;
                        break;
                    case TypeCode.UInt64:
                        enumValueLong = (ulong)enumValueObject;
                        break;
                    default:
                        return false;   // should never happen
                }
                retVal |= enumValueLong;
            }
            result = (TEnum)Enum.ToObject(enumType, retVal);
            return true;
        }

        // the value may be a number, so parse it directly
        switch (enumTypeCode) {
            case TypeCode.SByte:
                sbyte sb;
                if (!SByte.TryParse(value, out sb))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, sb);
                break;
            case TypeCode.Byte:
                byte b;
                if (!Byte.TryParse(value, out b))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, b);
                break;
            case TypeCode.Int16:
                short i16;
                if (!Int16.TryParse(value, out i16))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i16);
                break;
            case TypeCode.UInt16:
                ushort u16;
                if (!UInt16.TryParse(value, out u16))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u16);
                break;
            case TypeCode.Int32:
                int i32;
                if (!Int32.TryParse(value, out i32))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i32);
                break;
            case TypeCode.UInt32:
                uint u32;
                if (!UInt32.TryParse(value, out u32))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u32);
                break;
            case TypeCode.Int64:
                long i64;
                if (!Int64.TryParse(value, out i64))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, i64);
                break;
            case TypeCode.UInt64:
                ulong u64;
                if (!UInt64.TryParse(value, out u64))
                    return false;
                result = (TEnum)Enum.ToObject(enumType, u64);
                break;
            default:
                return false; // should never happen
        }

        return true;
    }

Answer 3

在NLog，我们还需要Enum.TryParse.Net 3.5。我们已经实现了受这篇文章影响的基本功能（仅解析、区分大小写和不区分大小写、无标志）。

这个基本实现是高度单元测试的，因此它具有与 Microsoft 的 .Net 4 实现相同的行为。

/// <summary>
/// Enum.TryParse implementation for .net 3.5 
/// 
/// </summary>
/// <returns></returns>
/// <remarks>Don't uses reflection</remarks>
// ReSharper disable once UnusedMember.Local
private static bool TryParseEnum_net3<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct
{
    var enumType = typeof(TEnum);
    if (!enumType.IsEnum())
        throw new ArgumentException($"Type '{enumType.FullName}' is not an enum");

    if (StringHelpers.IsNullOrWhiteSpace(value))
    {
        result = default(TEnum);
        return false;
    }

    try
    {
        result = (TEnum)Enum.Parse(enumType, value, ignoreCase);
        return true;
    }
    catch (Exception)
    {
        result = default(TEnum);
        return false;
    }
}

并且正在使用：

public static class StringHelpers
{
    /// <summary>
    /// IsNullOrWhiteSpace, including for .NET 3.5
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [ContractAnnotation("value:null => true")]
    internal static bool IsNullOrWhiteSpace(string value)
    {
#if NET3_5

        if (value == null) return true;
        if (value.Length == 0) return true;
        return String.IsNullOrEmpty(value.Trim());
#else
        return string.IsNullOrWhiteSpace(value);
#endif
    }
}

代码可以在NLog GitHub 上找到，单元测试也在 GitHub (xUnit)

Answer 4

它不会是 Enum 上的静态方法（静态扩展方法不太有意义），但它应该可以工作

public static class EnumHelpers
{
    public static bool TryParse<TEnum>(string value, out TEnum result)
        where TEnum : struct
    {
        try
        {
            result = (TEnum)Enum.Parse(typeof(TEnum), value); 
        }
        catch
        {
            result = default;
            return false;
        }

        return true;
    }
}